/*
    * 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.plugins;
  
  import java.awt.AWTEvent;
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Graphics;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.Toolkit;
  import java.awt.event.AWTEventListener;
  import java.awt.event.ComponentEvent;
  import java.awt.event.ComponentListener;
  import java.awt.event.MouseEvent;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.JComponent;
  import javax.swing.JRootPane;
  import javax.swing.SwingUtilities;
  
  import com.cosylab.application.PlugIn;
  import com.cosylab.application.PlugInException;
  import com.cosylab.application.PlugInManager;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.PaintHelper;
  import com.cosylab.gui.displayers.DataState;
  import com.cosylab.gui.displayers.DataStateProvider;
  import com.cosylab.logging.DebugLogger;
  
  
  /**
   * A plugin class that listens for all Displayer and data state changes within
   * a CosyPanel and paints various warning and timeout simbols over affected
   * Displayers.
   *
   * @author Jernej Kamenik
   * @version 1.1, 10.7.2002
   *
   * @see com.cosybeans.gui.core.CosyPanel
   * @see com.cosybeans.gui.core.PlugIn
   * @see com.cosybeans.gui.displayers.Displayer
   */
  public class VitragePlugIn extends JComponent implements PlugIn,
  	PropertyChangeListener, ComponentListener
  {
  
  	private static final long serialVersionUID = 1L;
  	/**
  	 * Property name for antialiasing boolean flag. Witrage plugin checks for
  	 * this properti in configuration of parent application panel and use it
  	 * when painting simbols.
  	 */
  	public final static String ENHANCED = "vitrageplugin.antialiasing";
  	private final static Logger logger = DebugLogger.getLogger("VP", Level.OFF);
  
  	//private PlugInManager manager = null;
  	private Container contentPane = null;
  	private List<DataStateProvider> displayers = null;
  	private boolean isEnabled;
  	private boolean isInHierarchy;
  
  	/**
  	 * Constructor for VitragePlugin
  	 */
  	public VitragePlugIn()
  	{
  		super();
  		setOpaque(false);
  		displayers = new ArrayList<DataStateProvider>();
  	}
  
  	/**
  	 * Creates vitrage plugin, which directly hooks up to parent without Cosy
  	 * framework.
  	 *
 	 * @param comp thecomponent, which subcomponents will be examined for
 	 *        Displayer instances
 	 */
 	public VitragePlugIn(JComponent comp)
 	{
 		this();
 		installToRoot(comp.getRootPane());
 
 		hookAWT(comp);
 	}
 
 	private void hookAWT(Container comp)
 	{
 		Component[] components = comp.getComponents();
 
 		if (components == null) {
 			return;
 		}
 
 		for (int i = 0; i < components.length; i++) {
 			if (components[i] instanceof DataStateProvider) {
 				hookDisplayer((DataStateProvider)components[i]);
 			}
 
 			if (components[i] instanceof Container) {
 				hookAWT((Container)components[i]);
 			}
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.application.PlugIn#installPlugIn(com.cosylab.application.PlugInManager)
 	 */
 	public void installPlugIn(PlugInManager manager) throws PlugInException
 	{
 		if (manager == null) {
 			throw new NullPointerException("manager");
 		}
 
 		logger.info("Installing to " + manager);
 
 /*		PaintHelper.setEnhanced(Boolean.getBoolean(
 		        panel.getApplication().getConfiguration().getProperty(ENHANCED,
 		            Boolean.TRUE.toString())));
 */
 
 		JRootPane root = SwingUtilities.getRootPane(manager.getOwnerPanel().getContentPane());
 
 		if (root != null) {
 			installToRoot(root);
 		}
 
 	}
 
 	private void installToRoot(JRootPane root)
 	{
 		contentPane = root.getContentPane();
 
 		if (!isInHierarchy) {
 			if (root != null) {
 				root.getLayeredPane().add(this, new Integer(1), -1);
 				setLocation(SwingUtilities.convertPoint(contentPane, 0, 0,
 				        getParent()));
 				setSize(contentPane.getSize());
 				root.addComponentListener(this);
 				isInHierarchy = true;
 				root.getLayeredPane().validate();
 
 				// Set the proper cursor (workaround)
 				// ike: not working for applets, security restriction
 				try {
 					Toolkit.getDefaultToolkit().addAWTEventListener(new CursorListener(
 					        contentPane), AWTEvent.MOUSE_EVENT_MASK);
 				} catch (SecurityException e) {
 					System.out.println(
 					    "No permission to access AWT, Vitrage my not function property: "
 					    + e.getMessage());
 				}
 			}
 		}
 	}
 
 	private void hookDisplayer(DataStateProvider disp)
 	{
 		logger.fine("disp " + disp);
 		disp.addPropertyChangeListener(this);
 
 		if (disp.getDataState().type != DataState.NORMAL
 		    && disp.getDataState().type != DataState.CONNECTED) {
 			addPaintedDisplayer(disp);
 		}
 	}
 
 	@SuppressWarnings("unused")
 	private void unhookDisplayer(DataStateProvider disp)
 	{
 		logger.fine("disp " + disp);
 		disp.removePropertyChangeListener(this);
 		removePaintedDisplayer(disp);
 	}
 
 	/**
 	 * 
 	 * @param source
 	 */
 	public void displayerStateChanged(DataStateProvider source)
 	{
 		if (source.getDataState().type == DataState.NORMAL // connected is not neccessary normal
 		//|| source.getDataState().type == DataState.CONNECTED
 		) {
 			removePaintedDisplayer(source);
 		} else {
 			addPaintedDisplayer(source);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.application.PlugIn#destroy()
 	 */
 	public void destroy()
 	{
 	}
 
 	/**
 	 * Method for painting the vitrage over displayers.
 	 *
 	 * @param g Graphics object to be painted.
 	 *
 	 * @see PaintHelper
 	 */
 	public void paintComponent(Graphics g)
 	{
 		super.paintComponent(g);
 
 		if (isEnabled) {
 			logger.fine("Painting");
 
 			DataStateProvider displayer = null;
 			Component component = null;
 			long timeoutTime;
 			String state;
 			Rectangle r;
 
 			for (int i = 0; i < displayers.size(); i++) {
 				displayer = (DataStateProvider)displayers.get(i);
 				component = (Component)displayer;
 
 				if (!component.isShowing()) {
 					continue;
 				}
 
 				if (!component.isDisplayable()) {
 					continue;
 				}
 
 				r = SwingUtilities.convertRectangle(component.getParent(),
 					    component.getBounds(), this);
 
 				/*if (true) {
 				    g.setColor(Color.RED);
 				    g.drawOval(r.x,r.y,r.width,r.height);
 				    continue;
 				}*/
 				state = displayer.getDataState().type;
 				timeoutTime = displayer.getDataState().timestamp;
 
 				if (state == DataState.NOT_INITIALIZED
 				    || state == DataState.DISCONNECTED
 				    || state == DataState.UNDEFINED) {
 					logger.fine("Painting DISABLED " + displayer);
 					PaintHelper.paintDisabled(g.create(r.x, r.y, r.width,
 					        r.height), 0, 0, r.width, r.height);
 				} else {
 					int timeSize = (int)(Math.min(r.width, r.height) * 8.8 / 10);
 					int stateSize = (int)(Math.min(r.width, r.height) * 9. / 10);
 
 					if (stateSize < 1) {
 						stateSize = 1;
 					}
 
 					if (timeSize < 1) {
 						timeSize = 1;
 					}
 
 					int timeX = (r.width - timeSize) / 2;
 					int timeY = (r.height - timeSize) / 2;
 					int stateX = (r.width - stateSize) / 2;
 					int stateY = (r.height - stateSize) / 2;
 
 					if (state == DataState.WARNING) {
 						logger.fine("Painting WARNING " + displayer);
 						PaintHelper.paintWarning(g.create(r.x, r.y, r.width,
 						        r.height), stateX, stateY, stateSize);
 					} else if (state == DataState.ALARM) {
 						String severity= displayer.getDataState().description;
 						logger.fine("Painting ALARM " + displayer+ " "+severity);
 						if ("INVALID_ALARM".equals(severity)) {
 							PaintHelper.paintAlarmInvalid(g.create(r.x, r.y, r.width,
 					        r.height), stateX, stateY, stateSize);
 						} else if ("MAJOR_ALARM".equals(severity)) {
 							PaintHelper.paintAlarmMajor(g.create(r.x, r.y, r.width,
 					        r.height), stateX, stateY, stateSize);
 						} else if ("MINOR_ALARM".equals(severity)) {
 							PaintHelper.paintAlarmMinor(g.create(r.x, r.y, r.width,
 					        r.height), stateX, stateY, stateSize);
 						}
 					} else if (state == DataState.ERROR) {
 						logger.fine("Painting ERROR " + displayer);
 						PaintHelper.paintEmergency(g.create(r.x, r.y, r.width,
 						        r.height), stateX, stateY, stateSize);
 						PaintHelper.paintRectangle(g.create(r.x, r.y, r.width,
 						        r.height), 0, 0, r.width, r.height,
 						    ColorHelper.getEmergencyOutline(),
 						    Math.max(stateSize / 50,2));
 					} else if (state == DataState.TIMEOUT) {
 						logger.fine("Painting TIMEOUT " + displayer);
 						PaintHelper.paintTimeout(g.create(r.x, r.y, r.width,
 						        r.height), timeX, timeY, timeSize,
 						    new Date(timeoutTime));
 						PaintHelper.paintRectangle(g.create(r.x, r.y, r.width,
 						        r.height), 0, 0, r.width, r.height,
 						    ColorHelper.getTimeOutOutline(), Math.max(stateSize / 50,2));
 					}
 				}
 			}
 		}
 	}
 
 	private void addPaintedDisplayer(DataStateProvider displayer)
 	{
 		synchronized (displayers) {
 			if (!displayers.contains(displayer)) {
 				logger.fine("disp " + displayer);
 				displayers.add(displayer);
 
 				if (!isEnabled) {
 					setVitrageEnabled(true);
 				}
 			}
 		}
 
 		repaint();
 	}
 
 	private void removePaintedDisplayer(DataStateProvider displayer)
 	{
 		synchronized (displayers) {
 			if (displayers.contains(displayer)) {
 				logger.fine("disp " + displayer);
 				displayers.remove(displayer);
 
 				if (displayers.size() == 0) {
 					setVitrageEnabled(false);
 				}
 			}
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Enables/disable the vitrage.
 	 * 
 	 * @param enabled
 	 */
 	public void setVitrageEnabled(boolean enabled)
 	{
 		isEnabled = enabled;
 	}
 	
 	/**
 	 * Returns true if vitrage is enabled
 	 * 
 	 * @return
 	 */
 	public boolean isVitrageEnabled() {
 		return isEnabled;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.event.ComponentListener#componentHidden(java.awt.event.ComponentEvent)
 	 */
 	public void componentHidden(ComponentEvent e)
 	{
 		isEnabled = false;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.event.ComponentListener#componentMoved(java.awt.event.ComponentEvent)
 	 */
 	public void componentMoved(ComponentEvent e)
 	{
 		if (getParent() == null) {
 			return;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.event.ComponentListener#componentResized(java.awt.event.ComponentEvent)
 	 */
 	public void componentResized(ComponentEvent e)
 	{
 		setSize(contentPane.getSize());
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent)
 	 */
 	public void componentShown(ComponentEvent e)
 	{
 		isEnabled = true;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
 	 */
 	public void propertyChange(PropertyChangeEvent evt)
 	{
 		if (evt.getSource() instanceof DataStateProvider
 		    && ("dataState").equals(evt.getPropertyName())) {
 		    //bugfix RT#11580 by jkamenik
 		    DataState nds = (DataState)evt.getNewValue();
 		    DataState ods = (DataState)evt.getOldValue();
 		    if (nds == null || ods == null
 			    || nds.type != ods.type 
 			    || nds.description!=ods.description) {
 				displayerStateChanged((DataStateProvider)evt.getSource());
 			}
 		    //end bugfix
 		}
 	}
 
 	/**
 	 * Listen for all events that our check box is likely to be interested in.
 	 * Redispatch them to the check box.
 	 */
 	private class CursorListener implements AWTEventListener
 	{
 		Container contentPane;
 
 		/**
 		 * Creates a new CursorListener object.
 		 *
 		 * @param contentPane DOCUMENT ME!
 		 */
 		public CursorListener(Container contentPane)
 		{
 			this.contentPane = contentPane;
 		}
 		
 		/*
 		 * (non-Javadoc)
 		 * @see java.awt.event.AWTEventListener#eventDispatched(java.awt.AWTEvent)
 		 */
 		public void eventDispatched(AWTEvent event)
 		{
 			if (event instanceof MouseEvent) {
 				MouseEvent evt = (MouseEvent)event;
 				Point ePt = evt.getPoint();
 				Point pt = SwingUtilities.convertPoint(evt.getComponent(),
 					    ePt.x, ePt.y, contentPane);
 				Component topC = SwingUtilities.getDeepestComponentAt(contentPane,
 					    pt.x, pt.y);
 
 				if (topC != null) {
 					setCursor(topC.getCursor());
 				}
 			}
 		}
 	}
 }
 
 /* __oOo__ */