package de.desy.acop.video;
   
   import java.awt.BorderLayout;
   import java.awt.Color;
   import java.awt.Cursor;
   import java.awt.Dimension;
   import java.awt.Graphics;
   import java.awt.Graphics2D;
   import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.Rectangle;
  import java.awt.Shape;
  import java.awt.datatransfer.DataFlavor;
  import java.awt.datatransfer.Transferable;
  import java.awt.dnd.DnDConstants;
  import java.awt.dnd.DragGestureEvent;
  import java.awt.dnd.DragGestureListener;
  import java.awt.dnd.DragSource;
  import java.awt.dnd.DragSourceAdapter;
  import java.awt.dnd.DropTarget;
  import java.awt.dnd.DropTargetAdapter;
  import java.awt.dnd.DropTargetDragEvent;
  import java.awt.dnd.DropTargetDropEvent;
  import java.awt.event.ActionEvent;
  import java.awt.event.MouseEvent;
  import java.awt.geom.Rectangle2D;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.beans.PropertyVetoException;
  import java.io.File;
  
  import javax.swing.AbstractAction;
  import javax.swing.Action;
  import javax.swing.JComponent;
  import javax.swing.JFileChooser;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.JPopupMenu;
  import javax.swing.JScrollPane;
  import javax.swing.JViewport;
  import javax.swing.border.LineBorder;
  import javax.swing.filechooser.FileNameExtensionFilter;
  
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.RunnerHelper;
  import com.cosylab.util.CommonException;
  
  import de.desy.acop.displayers.selector.ConnectionCustomizer;
  import de.desy.acop.displayers.tools.AcopDisplayerParameters;
  import de.desy.acop.displayers.tools.AcopDisplayerParametersFlavor;
  import de.desy.acop.displayers.tools.ConnectionParametersFlavor;
  import de.desy.acop.displayers.tools.ConnectionParametersReceiver;
  import de.desy.acop.transport.ConnectionParameters;
  import de.desy.acop.video.analysis.AImage;
  import de.desy.acop.video.analysis.AnalysisMode;
  import de.desy.acop.video.analysis.ImageAnalysisEngine;
  import de.desy.acop.video.analysis.LuminosityColorDecoder;
  import de.desy.acop.video.displayer.ColorLookupPanel;
  import de.desy.acop.video.displayer.ColorMap;
  import de.desy.acop.video.displayer.ImageCLUT;
  import de.desy.acop.video.displayer.ImageDisplayer;
  import de.desy.acop.video.displayer.ImageZoom;
  import de.desy.acop.video.displayer.OverlayState;
  import de.desy.acop.video.displayer.TineHandler;
  import de.desy.acop.video.displayer.TineImageReceiver;
  import de.desy.tine.types.IMAGE;
  
  /**
   * 
   * <code>AcopVideo</code> is a an AcopBean which can display a video image. This
   * bean encapsulates the {@link ImageDisplayer} which handles all the rendering
   * of the image, while this wrapper handles the common ACOP features. It
   * implements {@link ConnectionParametersReceiver}, which allows it to use the
   * common {@link ConnectionCustomizer}. However, in contrary to other AcopBeans
   * the the AcopVideo connection is not created automatically. Data acquisition
   * is not started until the {@link #start()} method is called. AcopVideo also
   * implements other standard ACOP features such as drag and drop (drag and drop
   * requires holding down of the Control key), common customizer, info dialog
   * etc.
   * 
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   * @version $Id: Templates.xml,v 1.10 2004/01/13 16:17:13 jbobnar Exp $
   * 
   */
  public class AcopVideo extends JComponent implements ConnectionParametersReceiver, PopupManageable, TineImageReceiver {
  
  	private static final long serialVersionUID = 1L;
  
  	public static final String PROPERTY_LIVE_MODE = "liveMode";
  	public static final String PROPERTY_AIMAGE = "aImage";
  	public static final String PROPERTY_CAN_CHANGE_SETTINGS = "canChangeSettings";
  	public static final String PROPERTY_DISPLAY_CLUT_HEADER = "displayClutHeader";
  	public static final String DISPLAY_STATISTISC = "displayStatistics";
  
  	/**
  	 * ImageDisplayer for image displaying
 	 */
 	private ImageDisplayer imageDisplayer;
 
 	/**
 	 * SideProfileDisplayers for horizontal and vertical profile display
 	 */
 	private SideProfileDisplayer horizontalDisplayer;
 	private SideProfileDisplayer verticalDisplayer;
 
 	/**
 	 * NumericDataDisplayer displays image analysis data
 	 */
 	private NumericDataDisplayer numericDataDisplayer;
 
 	/**
 	 * The layout of displayer panel
 	 */
 	private GridBagLayout layout;
 
 	/**
 	 * The panel for displayers
 	 */
 	private JPanel displayerPanel;
 
 	/**
 	 * The panel for Color LookUp Table (CLUT).
 	 */
 	private JViewport clutHeader;
 
 	/**
 	 * The selected analysis mode
 	 */
 	private AnalysisMode analysisMode = AnalysisMode.NO_ANALYSIS;
 
 	/**
 	 * Can analysis settings be changed?
 	 */
 	private boolean canChangeSettings = false;
 
 	/**
 	 * Toggle display numerical analysis values
 	 */
 	private boolean displayNumericalValues = false;
 
 	/**
 	 * Toggle display CLUT (Color LookUp Table) panel
 	 */
 	private boolean displayClutHeader = false;
 
 	/**
 	 * The weight of display decorations
 	 */
 	private double decorationsWeight = 0.2;
 
 	/**
 	 * Takes care of analyzing images
 	 */
 	private ImageAnalysisEngine imageAnalysisEngine;
 
 	/**
 	 * TineHandler which is used for data acquisition from the remote point
 	 */
 	private TineHandler tineHandler;
 
 	/**
 	 * Currently selected and applied ConnectionParameters
 	 */
 	private ConnectionParameters connParams;
 
 	/**
 	 * the customizer for this AcopBean
 	 */
 	private AbstractCustomizerPanel customizer;
 
 	/**
 	 * Popup manager
 	 */
 	private PopupManager popupManager;
 
 	/**
 	 * ACOP video information dialog
 	 */
 	private AcopVideoInfoDialog infoDialog;
 
 	/**
 	 * Bean is live mode state
 	 */
 	private boolean isLiveMode;
 
 	/**
 	 * File chooser for saving PNG images
 	 */
 	private JFileChooser chooser;
 
 	/**
 	 * Action start/stop from context menu
 	 */
 	private Action actionStart, actionStop;
 
 	/**
 	 * Displayer manager that manages the displays
 	 */
 	private DisplayerManager displayerManager;
 
 	/**
 	 * The current </code>AImage</code>
 	 */
 	private AImage aImage;
 
 	/**
 	 * Determines whether popup is enabled or not
 	 */
 	private boolean popupEnabled;
 
 	/**
 	 * Constructs a new AcopVideo.
 	 * 
 	 */
 	public AcopVideo() {
 		super();
 		initialize();
 
 		Thread th = new Thread(new Runnable() {
 			public void run() {
 				if (tineHandler != null) {
 					tineHandler.closeLink();
 				}
 				getImageAnalysisEngine().stopRemoteAnalysis();
 
 			}
 		});
 		th.setDaemon(false);
 		Runtime.getRuntime().addShutdownHook(th);
 		// demo
 		// Thread th1 = new Thread(new Runnable(){
 		// public void run() {
 		// IMAGE splashScreen = new IMAGE(0);
 		// int c = 0;
 		// int num = 0;
 		// while(true) {
 		// createSplashScreen(splashScreen,c);
 		// splashScreen.getFrameHeader().frameNumber = num++;
 		// updateValue(splashScreen);
 		// c++;
 		// c = c%10;
 		// // System.out.println("update " + c);
 		// try {
 		// Thread.sleep(1000);
 		// } catch (Exception e) {
 		// e.printStackTrace();
 		// }
 		// }
 		// }
 		//			
 		// private void createSplashScreen(IMAGE aSplashScreen, int cc) {
 		// // ImageParser.loadImageFile("g:/temp/Data/Free_"+ cc + ".bmp",
 		// aSplashScreen);
 		// ImageParser.loadImageFile("g:/temp/Data/test0.bmp", aSplashScreen);
 		// // ImageParser.loadImageFile("g:/Bg1.png", aSplashScreen);
 		// // if (cc % 2 == 0) {
 		// // ImageParser.loadImageFile("g:/Bg1.png", aSplashScreen);
 		// // } else {
 		// // ImageParser.loadImageFile("g:/Bg2.png", aSplashScreen);
 		// // }
 		// // aSplashScreen.getFrameHeader().bytesPerPixel=3;
 		// // aSplashScreen.getFrameHeader().effectiveBitsPerPixel=24;
 		// }
 		// });
 		// th1.start();
 	}
 
 	private void initialize() {
 		imageDisplayer = new ImageDisplayer() {
 
 			private static final long serialVersionUID = 310376L;
 
 			/*
 			 * (non-Javadoc)
 			 * 
 			 * @see
 			 * de.desy.acop.video.displayer.ImageDisplayer#paintComponent(java
 			 * .awt.Graphics)
 			 */
 			@Override
 			protected void paintComponent(Graphics g) {
 				super.paintComponent(g);
 				Graphics2D g2 = (Graphics2D) g;
 				if (getDisplayerManager().getDraggingRectangle() != null) {
 					Rectangle2D r = getDisplayerManager().getDraggingRectangle();
 					if (r != null) {
 						g2.setPaint(Definitions.getRoiSelectingColor());
 						g2.draw(r);
 					}
 				}
 				if (getDisplayerManager().isRoiSelected()) {
 					Rectangle2D r = getDisplayerManager().getScaledSelectedRectangle();
 					if (r != null) {
 						getDisplayerManager().updateImageDisplayerSize(getSize());
 						g2.setPaint(Definitions.getRoiColor());
 						g2.draw(r);
 					}
 				}
 				if (getDisplayerManager().isThresholdROISelected()) {
 					Rectangle2D r = getDisplayerManager().getScaledThresholdROIRectangle();
 					if (r != null) {
 						getDisplayerManager().updateImageDisplayerSize(getSize());
 						g2.setPaint(Definitions.getThresholdRoiColor());
 						g2.draw(r);
 					}
 				}
 				if (getDisplayerManager().isCrossAvailable()) {
 					Shape c = getDisplayerManager().getCross();
 					if (c != null) {
 						g2.setPaint(Definitions.getStatisticsColor());
 						g2.draw(c);
 					}
 				}
 				if (getDisplayerManager().isCrossFitAvailable()) {
 					Shape c = getDisplayerManager().getCrossFit();
 					if (c != null) {
 						g2.setPaint(Definitions.getFitColor());
 						g2.draw(c);
 					}
 				}
 			}
 		};
 
 		setPopupEnabled(true);
 
 		// imageDisplayer.addPropertyChangeListener(ImageDisplayer.PROPERTY_CLUT,
 		// new PropertyChangeListener() {
 		imageDisplayer.addPropertyChangeListener(ImageDisplayer.PROPERTY_COLOR_MAP, new PropertyChangeListener() {
 			@Override
 			public void propertyChange(PropertyChangeEvent evt) {
 				ColorLookupPanel clutPanel = (ColorLookupPanel) getClutHeader().getComponent(0);
 				clutPanel.setCLUT((ImageCLUT) evt.getNewValue());
 				clutPanel.repaint();
 			}
 		});
 
 		// create handler for receiving TINE IMAGE
 		tineHandler = new TineHandler(this);
 
 		// prepare main GUI
 		setLayout(new BorderLayout());
 		add(getDisplayerPanel(), BorderLayout.CENTER);
 		add(getNumericalDataDisplayer(), BorderLayout.SOUTH);
 
 		// Add DragAndDrop handler
 		setDropTarget(new DropTarget(this, new DropTargetAdapter() {
 
 			/**
 			 * Checks the flavors and the action of the given event and returns
 			 * true if the event is acceptable.
 			 */
 			private boolean isAcceptable(DropTargetDragEvent dtde) {
 				DataFlavor[] f = dtde.getCurrentDataFlavors();
 
 				boolean accept = false;
 
 				for (int i = 0; i < f.length; i++) {
 					if (f[i] == AcopVideoParametersFlavor.FLAVOR || f[i] == AcopDisplayerParametersFlavor.FLAVOR
 							|| f[i] == ConnectionParametersFlavor.FLAVOR || f[i] == DataFlavor.stringFlavor) {
 						accept = true;
 
 						break;
 					}
 				}
 
 				return (accept & (dtde.getDropAction() & DnDConstants.ACTION_COPY_OR_MOVE) != 0);
 			}
 
 			public void dragEnter(DropTargetDragEvent dtde) {
 				if (!isAcceptable(dtde)) {
 					dtde.rejectDrag();
 					return;
 				}
 			}
 
 			public void dragOver(DropTargetDragEvent dtde) {
 				if (!isAcceptable(dtde)) {
 					dtde.rejectDrag();
 					return;
 				}
 			}
 
 			public void dropActionChanged(DropTargetDragEvent dtde) {
 				if (!isAcceptable(dtde)) {
 					dtde.rejectDrag();
 					return;
 				}
 			}
 
 			public void drop(DropTargetDropEvent dtde) {
 				// accept drop
 				dtde.acceptDrop(DnDConstants.ACTION_COPY);
 				Transferable transferable = dtde.getTransferable();
 				try {
 					// check the supported data flavors and apply the
 					// transferred data to this bean
 					if (transferable.isDataFlavorSupported(AcopVideoParametersFlavor.FLAVOR)) {
 						AcopVideoParameters p = (AcopVideoParameters) transferable
 								.getTransferData(AcopVideoParametersFlavor.FLAVOR);
 
 						setConnectionParameters(p.getConnectionParameters());
 						setImageZoom(p.getImageZoom());
 						setOverlayState(p.getOverlayState());
 						setAOIZoom(p.isAOIZoom());
 						setHistogramEqualisation(p.isHistogramEqualisation());
 						setHistogramMin(p.getHistogramMin());
 						setHistogramMax(p.getHistogramMax());
 						setKeepAspectRatio(p.isKeepAspectRatio());
 
 						imageDisplayer.setCLUT(new ImageCLUT(p.getColorMap(), imageDisplayer.getCLUT()
 								.getComponentSize()));
 
 					} else if (transferable.isDataFlavorSupported(AcopDisplayerParametersFlavor.FLAVOR)) {
 						AcopDisplayerParameters p = (AcopDisplayerParameters) transferable
 								.getTransferData(AcopDisplayerParametersFlavor.FLAVOR);
 						setConnectionParameters(p.getConnectionParameters());
 					} else if (transferable.isDataFlavorSupported(ConnectionParametersFlavor.FLAVOR)) {
 						ConnectionParameters p = (ConnectionParameters) transferable
 								.getTransferData(ConnectionParametersFlavor.FLAVOR);
 						setConnectionParameters(p);
 					} else if (transferable.isDataFlavorSupported(DataFlavor.stringFlavor)) {
 						String p = (String) transferable.getTransferData(DataFlavor.stringFlavor);
 						try {
 							setConnectionParameters(new ConnectionParameters(p));
 						} catch (RuntimeException e) {
 							dtde.dropComplete(false);
 							return;
 						}
 					} else {
 						dtde.dropComplete(false);
 						return;
 					}
 					dtde.dropComplete(true);
 				} catch (Exception e) {
 					e.printStackTrace();
 				}
 			}
 
 		}));
 
 		// initialize the image displayer as drag source
 		DragSource dragSource = DragSource.getDefaultDragSource();
 		dragSource.createDefaultDragGestureRecognizer(this, DnDConstants.ACTION_COPY_OR_MOVE,
 				new DragGestureListener() {
 					public void dragGestureRecognized(DragGestureEvent dge) {
 						if (dge.getTriggerEvent() instanceof MouseEvent) {
 							if (!((MouseEvent) dge.getTriggerEvent()).isControlDown())
 								return;
 						}
 
 						AcopVideoParameters p = new AcopVideoParameters( //
 								getConnectionParameters(), //
 								imageDisplayer.isAOIZoom(), //
 								imageDisplayer.getImageZoom(), //
 								imageDisplayer.getOverlayState(), //
 								imageDisplayer.isKeepAspectRatio(), //
 								imageDisplayer.isHistogramEqualisation(), //
 								imageDisplayer.getHistogramMin(), //
 								imageDisplayer.getHistogramMax(), //
 								// _imageDisplayer.getColorMap(), //
 								imageDisplayer.getCLUT().getColorMap(), //
 								getClutHeader().isVisible());
 
 						Transferable transferable = new AcopVideoTransferable(p);
 						dge.startDrag(new Cursor(Cursor.MOVE_CURSOR), transferable, new DragSourceAdapter() {
 						});
 					}
 				});
 
 	}
 
 	private SideProfileDisplayer getHorizontalDisplayer() {
 		if (horizontalDisplayer == null) {
 			horizontalDisplayer = new SideProfileDisplayer(true);
 			horizontalDisplayer.setVisible(isAnalysisEnabled());
 		}
 		return horizontalDisplayer;
 	}
 
 	private SideProfileDisplayer getVerticalDisplayer() {
 		if (verticalDisplayer == null) {
 			verticalDisplayer = new SideProfileDisplayer(false);
 			verticalDisplayer.setVisible(isAnalysisEnabled());
 		}
 		return verticalDisplayer;
 	}
 
 	private NumericDataDisplayer getNumericalDataDisplayer() {
 		if (numericDataDisplayer == null) {
 			numericDataDisplayer = new NumericDataDisplayer();
 			numericDataDisplayer.setVisible(displayNumericalValues);
 		}
 		return numericDataDisplayer;
 	}
 
 	protected DisplayerManager getDisplayerManager() {
 		if (displayerManager == null) {
 			displayerManager = new DisplayerManager(getImageAnalysisEngine(), getImageDisplayer(),
 					getHorizontalDisplayer(), getVerticalDisplayer());
 		}
 		return displayerManager;
 	}
 
 	public void setAnalysisServerConnectionParameters(ConnectionParameters param) {
 		getImageAnalysisEngine().setAnalysisServerConnectionParameters(param);
 	}
 
 	/**
 	 * Sets the background image to be used by this
 	 * </code>ImageAnalysisEngine</code>.
 	 * 
 	 * @param background
 	 *            the image to set
 	 * @deprecated use {@link #setPreciseBackgroundImage(double[], int)}
 	 */
 	public synchronized void setBackgroundImage(IMAGE background) {
 		getImageAnalysisEngine().setBackground(background);
 	}
 
 	/**
 	 * Gets the background image used by this </code>ImageAnalysisEngine</code>.
 	 * 
 	 * @return the background image
 	 * @deprecated use {@link #getPreciseBackgroundImage()}
 	 */
 	public synchronized IMAGE getBackgroundImage() {
 		return getImageAnalysisEngine().getBackground();
 	}
 
 	/**
 	 * Sets the region of interest for the analysis.
 	 * 
 	 * @param rect
 	 *            the region of interest rectangle
 	 */
 	public void setROI(Rectangle rect) {
 		getImageAnalysisEngine().setRoi(rect.x, rect.y, rect.width, rect.height);
 	}
 
 	/**
 	 * Returns the region of interest.
 	 * 
 	 * @return the region of interest
 	 */
 	public Rectangle getROI() {
 		return getImageAnalysisEngine().getROI();
 	}
 
 	/**
 	 * Sets the region of interest used for threshold calculation.
 	 * 
 	 * @param rect
 	 *            the region of interest used for threshold calculation
 	 */
 	public void setThresholdROI(Rectangle rect) {
 		getImageAnalysisEngine().setRoi2(rect.x, rect.y, rect.width, rect.height);
 	}
 
 	/**
 	 * Returns the region of interest used for threshold calculation.
 	 * 
 	 * @return the region of interest used for thereshold calculation
 	 */
 	public Rectangle getThresholdROI() {
 		return getImageAnalysisEngine().getThresholdROI();
 	}
 
 	/**
 	 * Sets a flag if the threshold should be calculated automatically within
 	 * the threshold region of interest.
 	 * 
 	 * @param automatic
 	 *            true if threshold is calculated automatically or false
 	 *            otherwise
 	 * @see #setThresholdROI(Rectangle)
 	 */
 	public void setAutomaticThresholdCalculation(boolean automatic) {
 		getImageAnalysisEngine().setCalculateThreshold(automatic);
 	}
 
 	/**
 	 * Returns true if the threshold is calculated automatically within the
 	 * threshold region of interest.
 	 * 
 	 * @return true if threshold is calculated automatically or false otherwise
 	 */
 	public boolean isAutomaticThresholdCalculation() {
 		return getImageAnalysisEngine().isCalculateThreshold();
 	}
 
 	/**
 	 * Sets the precise background image double array and width of the image.
 	 * Negative values in the image array are also accepted and will be used
 	 * during analysis but not for presentation.
 	 * 
 	 * @param image
 	 *            the image double array
 	 * @param width
 	 *            the width of the background image
 	 */
 	public synchronized void setPreciseBackgroundImage(double[] image, int width) {
 		getImageAnalysisEngine().setPreciseBackground(image, width);
 	}
 
 	/**
 	 * Returns the precise background image double array.
 	 * 
 	 * @return the background image double array
 	 */
 	public synchronized double[] getPreciseBackgroundImage() {
 		return getImageAnalysisEngine().getPreciseBackground();
 	}
 
 	/**
 	 * Returns the background image width as set on the analysis engine.
 	 * 
 	 * @return the background width
 	 */
 	public synchronized int getBackgroundImageWidth() {
 		return getImageAnalysisEngine().getBackgroundWidth();
 	}
 
 	/**
 	 * Sets the threshold value, which discards all pixels which have returned
 	 * by <code>ColorDecoder</code> lover than threshold value. Threshold value
 	 * has effect only between values Const2D and Amplitude2D as described by
 	 * <code>AImage</code>.
 	 * 
 	 * @see AImage
 	 * @see AImage#getAmplitude2D()
 	 * @see AImage#getConst2D()
 	 * 
 	 * @param threshold
 	 *            the threshold value to set
 	 */
 	public synchronized void setThreshold(final double threshold) {
 		ImageAnalysisEngine engine = getImageAnalysisEngine();
 		if (engine != null) {
 			engine.setThreshold(threshold);
 		}
 	}
 
 	/**
 	 * Gets the threshold value.
 	 * 
 	 * @see #setThreshold(double)
 	 * 
 	 * @return the threshold value
 	 */
 	public synchronized double getThreshold() {
 		return getImageAnalysisEngine().getThreshold();
 	}
 
 	protected synchronized ImageAnalysisEngine getImageAnalysisEngine() {
 		if (imageAnalysisEngine == null) {
 			imageAnalysisEngine = new ImageAnalysisEngine(new LuminosityColorDecoder());
 			imageAnalysisEngine.addPropertyChangeListener(new PropertyChangeListener() {
 				@Override
 				public void propertyChange(PropertyChangeEvent evt) {
 					String propertyName = evt.getPropertyName();
 					if (propertyName == ImageAnalysisEngine.PROPERTY_A_IMAGE) {
 						AImage aImage = (AImage) evt.getNewValue();
 						setAImage(aImage);
 					} else if (propertyName == ImageAnalysisEngine.PROPERTY_RESET) {
 						getImageDisplayer().resetForReceiving();
 					}
 				}
 			});
 		}
 		return imageAnalysisEngine;
 	}
 
 	private GridBagLayout getDisplayerPanelLayout() {
 		if (layout == null) {
 			layout = new GridBagLayout();
 		}
 		return layout;
 	}
 
 	private JPanel getDisplayerPanel() {
 		if (displayerPanel == null) {
 			displayerPanel = new JPanel(getDisplayerPanelLayout());
 			GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.CENTER,
 					GridBagConstraints.BOTH, new Insets(0, 0, 0, 0), 0, 0);
 
 			JScrollPane scroller = new JScrollPane(imageDisplayer);
 			scroller.setAutoscrolls(true);
 			scroller.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
 			scroller.getViewport().addChangeListener(getDisplayerManager().getViewPortListener());
 			scroller.setColumnHeader(getClutHeader());
 			displayerPanel.add(scroller, gbc);
 
 			gbc.gridy++;
 			gbc.weighty = decorationsWeight;
 			gbc.insets = new Insets(0, 1, 0, 1);
 			getHorizontalDisplayer().setBorder(new LineBorder(Color.BLACK, 1));
 			displayerPanel.add(getHorizontalDisplayer(), gbc);
 			gbc.gridy--;
 			gbc.gridx++;
 			gbc.weightx = decorationsWeight;
 			gbc.insets = new Insets(1, 0, 1, 0);
 			getVerticalDisplayer().setBorder(new LineBorder(Color.BLACK, 1));
 			displayerPanel.add(getVerticalDisplayer(), gbc);
 		}
 		return displayerPanel;
 	}
 
 	private JViewport getClutHeader() {
 		if (clutHeader == null) {
 			clutHeader = new JViewport();
 			clutHeader.add(new ColorLookupPanel(null));
 			clutHeader.setVisible(displayClutHeader);
 			clutHeader.setPreferredSize(new Dimension(0, 30));
 		}
 		return clutHeader;
 	}
 
 	/**
 	 * Sets the color map for the image.
 	 * 
 	 * @param newValue
 	 *            - new color map
 	 */
 	public void setColorMap(ColorMap newValue) {
 		ColorMap oldValue = getColorMap();
 		imageDisplayer.setColorMap(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_COLOR_MAP, oldValue, newValue);
 	}
 
 	/**
 	 * Returns the color map used to render the image.
 	 * 
 	 * @return the applied color map
 	 * @see ImageDisplayer#getColorMap()
 	 */
 	public ColorMap getColorMap() {
 		return imageDisplayer.getColorMap();
 	}
 
 	/**
 	 * Sets the image zoom
 	 * 
 	 * @param newValue
 	 */
 	public void setImageZoom(ImageZoom newValue) {
 		ImageZoom oldValue = getImageZoom();
 		imageDisplayer.setImageZoom(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_IMAGE_ZOOM, oldValue, newValue);
 	}
 
 	/**
 	 * Returns image zoom.
 	 */
 	public ImageZoom getImageZoom() {
 		return imageDisplayer.getImageZoom();
 	}
 
 	/**
 	 * @param newValue
 	 *            set overlay mode always on (true) or off(false)
 	 */
 	public void setOverlayState(OverlayState newValue) {
 		OverlayState oldValue = getOverlayState();
 		imageDisplayer.setOverlayState(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_OVERLAY_STATE, oldValue, newValue);
 	}
 
 	/**
 	 * Returns overlay information state.
 	 */
 	public OverlayState getOverlayState() {
 		return imageDisplayer.getOverlayState();
 	}
 
 	/**
 	 * Switches 'histogram equalization' on or off. Get/Set. This method will do
 	 * nothing if the histogram equalization mode is already in the state about
 	 * to be set. After new assignment, drawing as well as repainting is
 	 * enforced to update all involved parts of code so that Histogram
 	 * Equalization is immediately applied to image.
 	 * 
 	 * @param newValue
 	 *            - switch histogram equalization on (true) or off (false)
 	 */
 	public void setHistogramEqualisation(boolean newValue) {
 		boolean oldValue = isHistogramEqualisation();
 		imageDisplayer.setHistogramEqualisation(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_HISTOGRAM_EQUALISATION, oldValue, newValue);
 	}
 
 	/**
 	 * returns whether histogram equalization (normalization) is currently
 	 * enabled. Get/Set.
 	 * 
 	 * @return true - histogram equalization is switched on<br>
 	 *         false - histogram equalization is switched off
 	 */
 	public boolean isHistogramEqualisation() {
 		return imageDisplayer.isHistogramEqualisation();
 	}
 
 	/** see {@link ImageDisplayer#setHistogramMin(int)} */
 	public void setHistogramMin(int newValue) {
 		// System.out.println("AcopVideo.setHistogramMin(" + newValue + ")");
 		int oldValue = getHistogramMin();
 		imageDisplayer.setHistogramMin(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_HISTOGRAM_MIN, oldValue, newValue);
 	}
 
 	/** @see {@link ImageDisplayer#getHistogramMin()} */
 	public int getHistogramMin() {
 		return imageDisplayer.getHistogramMin();
 	}
 
 	/** see {@link ImageDisplayer#setHistogramMax(int)} */
 	public void setHistogramMax(int newValue) {
 		// System.out.println("AcopVideo.setHistogramMax(" + newValue + ")");
 		int oldValue = getHistogramMax();
 		imageDisplayer.setHistogramMax(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_HISTOGRAM_MAX, oldValue, newValue);
 	}
 
 	/** @see {@link ImageDisplayer#getHistogramMax()} */
 	public int getHistogramMax() {
 		return imageDisplayer.getHistogramMax();
 	}
 
 	/**
 	 * Switches 'AOI zoom' on or off. Get/Set. This method will do nothing if
 	 * the AOI zoom mode is already in the state about to be set. Repainting is
 	 * enforced to have an immediate update.
 	 * 
 	 * @param newValue
 	 *            enable (true) or disable (false) AOI zooming
 	 */
 	public void setAOIZoom(boolean newValue) {
 		boolean oldValue = isAOIZoom();
 		imageDisplayer.setAOIZoom(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_AOI_ZOOM, oldValue, newValue);
 	}
 
 	/**
 	 * returns whether out zooming of AOI (no black border around AOI which
 	 * depicts full frame) is currently enabled. Get/Set.
 	 * 
 	 * @return true - AOI Zoom is switched on<br>
 	 *         false - AOI Zoom is switched off
 	 */
 	public boolean isAOIZoom() {
 		return imageDisplayer.isAOIZoom();
 	}
 
 	/**
 	 * Switches 'aspect ratio is kept' on or off. Get/Set. This method will do
 	 * nothing if the aspect ratio mode is already in the state about to be set.
 	 * Repainting is enforced to have an immediate update.
 	 * 
 	 * @param newValue
 	 *            enable (true) or disable (false) keeping of aspect ratio
 	 */
 	public void setKeepAspectRatio(boolean newValue) {
 		boolean oldValue = isKeepAspectRatio();
 		imageDisplayer.setKeepAspectRatio(newValue);
 		firePropertyChange(ImageDisplayer.PROPERTY_KEEP_ASPECT_RATIO, oldValue, newValue);
 	}
 
 	/**
 	 * returns whether 'aspect ratio is kept' is currently enabled. Get/Set.
 	 * 
 	 * @return true - 'aspect ratio is kept' is switched on<br>
 	 *         false - 'aspect ratio is kept' is switched off
 	 */
 	public boolean isKeepAspectRatio() {
 		return imageDisplayer.isKeepAspectRatio();
 	}
 
 	// mdavid: changed
 	/**
 	 * Returns true if this bean is in live mode (ConnectionParameters have been
 	 * set and start method has been invoked).
 	 * 
 	 * @return true if in live mode, false otherwise
 	 */
 	public boolean isLiveMode() {
 		return isLiveMode;
 	}
 
 	/**
 	 * Sets live mode (only internal used)
 	 * 
 	 * @param newValue
 	 *            - <code>true</code> if in live mode, otherwise
 	 *            <code>false</code>
 	 */
 	private void setLiveMode(boolean newValue) {
 		boolean oldValue = isLiveMode;
 		isLiveMode = newValue;
 		firePropertyChange(PROPERTY_LIVE_MODE, oldValue, newValue);
 	}
 
 	/**
 	 * Gets the current </code>AImage</code> object for this
 	 * </code>AcopVideo</code>.
 	 * 
 	 * @return the current </code>AImage</code>
 	 */
 	public AImage getAImage() {
 		return aImage;
 	}
 
 	/**
 	 * Sets an </code>AImage</code> object to this </code>AcopVideo</code>.
 	 * 
 	 * @param image
 	 *            the </code>AImage</code> to set
 	 */
 	private void setAImage(AImage image) {
 		if (this.aImage == image)
 			return;
 		AImage old = aImage;
 		aImage = image;
 		getDisplayerManager().updateAImage(aImage);
 		if (aImage == null)
 			getNumericalDataDisplayer().clearData();
 		else
 			getNumericalDataDisplayer().setData(aImage.getImageW(), aImage.getImageH(), aImage.getRoiX(),
 					aImage.getRoiY(), aImage.getRoiW(), aImage.getRoiH(), aImage.getThreshold(), aImage.getMeanX(),
 					aImage.getStdX(), aImage.getSideViewAmplitudeX(), aImage.getSideViewConstX(), aImage.getMeanXFit(),
 					aImage.getStdXFit(), aImage.getAmplitudeXFit(), aImage.getConstXFit(), aImage.getSlopeXFit(),
 					aImage.getMeanY(), aImage.getStdY(), aImage.getSideViewAmplitudeY(), aImage.getSideViewConstY(),
 					aImage.getMeanYFit(), aImage.getStdYFit(), aImage.getAmplitudeYFit(), aImage.getConstYFit(),
 					aImage.getSlopeYFit(), aImage.getStdA(), aImage.getStdB(), aImage.getAngle2D(),
 					aImage.getAmplitude2D(), aImage.getConst2D());
 		firePropertyChange(PROPERTY_AIMAGE, old, aImage);
 	}
 
 	/**
 	 * Gets layout weight for decorations.
 	 * 
 	 * @return the layout weight for decorations
 	 */
 	public double getDecorationsWeight() {
 		return decorationsWeight;
 	}
 
 	/**
 	 * Sets layout weight for decorations.
 	 * 
 	 * @param decorationsWeight
 	 *            the layout weight for decorations to set
 	 */
 	public void setDecorationsWeight(double decorationsWeight) {
 		if (this.decorationsWeight == decorationsWeight)
 			return;
 		this.decorationsWeight = decorationsWeight;
 		GridBagConstraints gbc = getDisplayerPanelLayout().getConstraints(getHorizontalDisplayer());
 		gbc.weighty = decorationsWeight;
 		getDisplayerPanelLayout().setConstraints(getHorizontalDisplayer(), gbc);
 		gbc = getDisplayerPanelLayout().getConstraints(getVerticalDisplayer());
 		gbc.weightx = decorationsWeight;
 		getDisplayerPanelLayout().setConstraints(getVerticalDisplayer(), gbc);
 		getDisplayerPanelLayout().layoutContainer(getDisplayerPanel());
 	}
 
 	/**
 	 * Gets the </code>AnalysisMode</code> for this </code>AcopVideo</code>.
 	 * 
 	 * @return the selected </code>AnalysisMode</code>
 	 */
 	public AnalysisMode getAnalysisMode() {
 		return analysisMode;
 	}
 
 	/**
 	 * Sets the </code>AnalysisMode</code> for this </code>AcopVideo</code>.
 	 * 
 	 * @param analysisMode
 	 *            the the </code>AnalysisMode</code>
 	 */
 	public void setAnalysisMode(AnalysisMode analysisMode) {
 		if (this.analysisMode == analysisMode)
 			return;
 		this.analysisMode = analysisMode;
 		getHorizontalDisplayer().setVisible(isAnalysisEnabled());
 		getVerticalDisplayer().setVisible(isAnalysisEnabled());
 		setAImage(null);
 		boolean local = analysisMode != AnalysisMode.REMOTE_ANALYSIS;
 		getImageAnalysisEngine().setLocalAnalysisMode(local);
 		setCanChangeSettings(analysisMode == AnalysisMode.LOCAL_ANALYSIS);
 	}
 
 	/**
 	 * Sets the flag whether fitting should be performed during the analysis.
 	 * 
 	 * @param perform
 	 *            true to perform fit or false otherwise
 	 */
 	public void setPerformFit(boolean perform) {
 		if (getImageAnalysisEngine().isPerformFit())
 			return;
 		getImageAnalysisEngine().setPerformFit(perform);
 		firePropertyChange("performFit", !perform, perform);
 	}
 
 	/**
 	 * Returns true if fitting is performed or false otherwise. Fitting is
 	 * performed only if analysis is turned on (local or remote).
 	 * 
 	 * @return true if fitting is performed or false otherwise
 	 */
 	public boolean isPerformFit() {
 		return getImageAnalysisEngine().isPerformFit();
 	}
 
 	/**
 	 * Returns true if statistics are displayed or false otherwise.
 	 * 
 	 * @return true if statistics are displayed in the sideview or false if not
 	 */
 	public boolean isDisplayStatistics() {
 		return getDisplayerManager().isDisplayStatistics();
 	}
 
 	/**
 	 * Sets the flag whether the statistics are displayed on the canvas or not.
 	 * 
 	 * @param display
 	 *            true if statistics are displayed or false otherwise
 	 */
 	public void setDisplayStatistics(boolean display) {
 		// always fire an event
 		getDisplayerManager().setDisplayStatistics(display);
 		firePropertyChange(DISPLAY_STATISTISC, !display, display);
 		repaint();
 	}
 
 	private boolean isAnalysisEnabled() {
 		if (analysisMode == AnalysisMode.LOCAL_ANALYSIS || analysisMode == AnalysisMode.REMOTE_ANALYSIS)
 			return true;
 		return false;
 	}
 
 	/**
 	 * Checks if analysis settings can be changed.
 	 * 
 	 * @return </code>true</code> if analysis settings can be changed and
 	 *         </code>false</code> otherwise
 	 */
 	public boolean isCanChangeSettings() {
 		return canChangeSettings;
 	}
 
 	/**
 	 * Sets if analysis settings can be changed.
 	 * 
 	 * @param canChange
 	 *            if </code>true</code> analysis settings can be changed and
 	 *            </code>false</code> if not
 	 */
 	public void setCanChangeSettings(boolean canChange) {
 		if (canChangeSettings == canChange)
 			return;
 		canChangeSettings = canChange;
 		firePropertyChange(PROPERTY_CAN_CHANGE_SETTINGS, !canChange, canChange);
 		getDisplayerManager().setCanChangeSettings(canChange);
 	}
 
 	/**
 	 * Gets the display numerical values option.
 	 * 
 	 * @return </code>true</code> if numerical values are displayed and
 	 *         </code>false</code> if they are not
 	 */
 	public boolean isDisplayNumericalValues() {
 		return displayNumericalValues;
 	}
 
 	/**
 	 * Sets the display numerical values option.
 	 * 
 	 * @param displayNumericalValues
 	 *            if </code>true</code> numerical values are displayed and if
 	 *            </code>false</code> they are not
 	 */
 	public void setDisplayNumericalValues(boolean displayNumericalValues) {
 		this.displayNumericalValues = displayNumericalValues;
 		getNumericalDataDisplayer().setVisible(displayNumericalValues);
 	}
 
 	/**
 	 * Returns the display CLUT panel option.
 	 * 
 	 * @return </code>true</code> if CLUT panel is visible, otherwise
 	 *         </code>false</code>
 	 */
 	public boolean isDisplayClutHeader() {
 		return displayClutHeader;
 	}
 
 	/**
 	 * Makes the CLUT panel visible or invisible.
 	 * 
 	 * @param displayClutHeader
 	 *            - true to make the CLUT panel visible; false to make it
 	 *            invisible
 	 */
 	public void setDisplayClutHeader(boolean displayClutHeader) {
 		if (this.displayClutHeader == displayClutHeader)
 			return;
 		boolean oldValue = this.displayClutHeader;
 		this.displayClutHeader = displayClutHeader;
 		getClutHeader().setVisible(displayClutHeader);
 		firePropertyChange(PROPERTY_DISPLAY_CLUT_HEADER, oldValue, displayClutHeader);
 	}
 
 	/**
 	 * Finds the customizer for this bean.
 	 * 
 	 * @return the customized
 	 */
 	public AbstractCustomizerPanel getCustomizer() {
 		if (customizer == null)
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		return customizer;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see com.cosylab.gui.components.util.PopupManageable#getPopupManager()
 	 */
 	public PopupManager getPopupManager() {
 		if (popupManager == null) {
 			popupManager = new PopupManager(this, true);
 			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) {
 					saveAsPNG();
 				}
 			});
 
 			popupManager.addAction(new AbstractAction("Info...") {
 				private static final long serialVersionUID = 310376L;
 
 				public void actionPerformed(ActionEvent e) {
 					getInfoDialog().setVisible(true);
 					getInfoDialog().toFront();
 				}
 			});
 
 			actionStart = new AbstractAction("Start") {
 				private static final long serialVersionUID = 310376L;
 
 				public void actionPerformed(ActionEvent e) {
 					start();
 				}
 			};
 			actionStart.setEnabled(false); // mdavid: added
 			popupManager.addAction(actionStart);
 
 			actionStop = new AbstractAction("Stop") {
 				private static final long serialVersionUID = 1310376L;
 
 				public void actionPerformed(ActionEvent e) {
 					stop();
 				}
 			};
 			actionStop.setEnabled(false); // mdavid: added
 			popupManager.addAction(actionStop);
 
 			// disable this, in order for popup to be drawn on the awt canvas
 			JPopupMenu.setDefaultLightWeightPopupEnabled(false);
 		}
 		return popupManager;
 	}
 
 	/**
 	 * Saves TINE Image to PNG (in "archival" mode)
 	 */
 	public void saveAsPNG() {
 		JFileChooser chooser = getPngFileChooser("Save As");
 		int returnVal = chooser.showSaveDialog(this);
 		if (returnVal == JFileChooser.APPROVE_OPTION) {
 			String fileNamePath = chooser.getSelectedFile().getAbsolutePath();
 			if (!fileNamePath.toLowerCase().endsWith(".png")) {
 				int index = fileNamePath.lastIndexOf('.');
 				if (index >= 0) {
 					fileNamePath = fileNamePath.substring(0, index) + ".png";
 				} else {
 					fileNamePath = fileNamePath + ".png";
 				}
 			}
 			if (!imageDisplayer.saveAsPNGImage(fileNamePath))
 				JOptionPane.showMessageDialog(this, "Error saving image.", "Error", JOptionPane.ERROR_MESSAGE);
 		}
 	}
 
 	/**
 	 * Exports TINE Image to PNG (in "export" mode)
 	 */
 	public void exportToPNG() {
 		JFileChooser chooser = getPngFileChooser("Export");
 		int returnVal = chooser.showSaveDialog(this);
 		if (returnVal == JFileChooser.APPROVE_OPTION) {
 			String fileNamePath = chooser.getSelectedFile().getAbsolutePath();
 			if (!fileNamePath.toLowerCase().endsWith(".png")) {
 				int index = fileNamePath.lastIndexOf('.');
 				if (index >= 0)
 					fileNamePath = fileNamePath.substring(0, index) + ".png";
 				else
 					fileNamePath = fileNamePath + ".png";
 			}
 			if (!imageDisplayer.exportToPNG(fileNamePath))
 				JOptionPane.showMessageDialog(this, "Error saving image.", "Error", JOptionPane.ERROR_MESSAGE);
 		}
 	}
 
 	private JFileChooser getPngFileChooser(String dialogTitle) {
 		if (chooser == null) {
 			chooser = new JFileChooser(new File("."));
 			String[] fileType = { "png" };
 			FileNameExtensionFilter PNGfilter = new FileNameExtensionFilter("PNG files", fileType);
 			chooser.addChoosableFileFilter(PNGfilter);
 		}
 		chooser.setDialogTitle(dialogTitle);
 		return chooser;
 	}
 
 	private AcopVideoInfoDialog getInfoDialog() {
 		if (infoDialog == null) {
 			infoDialog = new AcopVideoInfoDialog(this);
 		}
 		return infoDialog;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @seede.desy.acop.displayers.tools.ConnectionParametersReceiver#
 	 * getConnectionParameters()
 	 */
 	public ConnectionParameters getConnectionParameters() {
 		return connParams;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @seede.desy.acop.displayers.tools.ConnectionParametersReceiver#
 	 * setConnectionParameters(de.desy.acop.transport.ConnectionParameters)
 	 */
 	public void setConnectionParameters(ConnectionParameters cp) throws CommonException, PropertyVetoException {
 
 		if (connParams == null) {
 			if (cp == null)
 				return;
 		} else if (connParams.equals(cp))
 			return;
 
 		ConnectionParameters oldValue = this.connParams;
 		connParams = cp;
 		stop();
 
 		firePropertyChange(CONNECTION_PARAMETERS_PROPERTY, oldValue, connParams);
 	}
 
 	//
 	// /**
 	// * Construct the remote name from the given parameters to be handled by
 	// the {@link TineHandler}.
 	// *
 	// * @param p
 	// * source parameters
 	// * @return context/server/device
 	// */
 	// private String getRemoteName(ConnectionParameters p) {
 	// if (p == null)
 	// return null;
 	// String remoteName = "/" + p.getDeviceContext() + "/" + p.getDeviceGroup()
 	// + "/";
 	// if (p.getDeviceName() != null && p.getDeviceName().length() != 0) {
 	// remoteName += p.getDeviceName();
 	// }
 	// return remoteName;
 	// }
 
 	/**
 	 * Starts data acquisition. Due to high duty task of rendering, the
 	 * AcopVideo will display image only after this method is invoked.
 	 * 
 	 * @see ImageDisplayer#setLiveTransfer(boolean)
 	 * @see TineHandler#openLink(String, de.desy.acop.transport.AccessMode, int)
 	 */
 	public void start() {
 		if (connParams == null)
 			return;
 
 		setEnabled(false);
 		// getCustomizer().closeDialog();
 		new Thread(new Runnable() {
 			public void run() {
 				try {
 					if (analysisMode == AnalysisMode.REMOTE_ANALYSIS) {
 						getImageAnalysisEngine().setAnalysisServerConnectionParameters(connParams);
 						getImageAnalysisEngine().startRemoteAnalysis();
 
 					} else
 						tineHandler.openLink(connParams);
 
 					imageDisplayer.setLiveTransfer(true);
 					setLiveMode(true);
 
 				} catch (Exception e) {
 					System.out.println(e);
 					JOptionPane.showMessageDialog(AcopVideo.this, "Error connecting to the address '"
 							+ connParams.getRemoteName() + "'.\n" + e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
 				} finally {
 					setEnabled(true);
 				}
 			}
 
 		}).start();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see javax.swing.JComponent#setEnabled(boolean)
 	 */
 	@Override
 	public void setEnabled(boolean enabled) {
 		super.setEnabled(enabled);
 		actionStart.setEnabled(!isLiveMode); // mdavid: added
 		actionStop.setEnabled(isLiveMode); // mdavid: added
 	}
 
 	/**
 	 * Stops data acquisition and image rendering.
 	 * 
 	 * @see ImageDisplayer#setLiveTransfer(boolean)
 	 * @see TineHandler#closeLink()
 	 */
 	public void stop() {
 		getImageAnalysisEngine().stopRemoteAnalysis();
 		tineHandler.closeLink();
 		imageDisplayer.setLiveTransfer(false);
 		setLiveMode(false);
 		setEnabled(false);
 	}
 
 	public static void main(String[] args) {
 		AcopVideo v = new AcopVideo();
 		RunnerHelper.runComponent(v, 500, 500);
 
 		// TODO why is this needed?
 		// ImageIO.write((BufferedImage) v._imageDisplayer.getSnapshotImage(),
 		// "PNG", new java.io.File("C:/test.png"));
 	}
 
 	public ImageDisplayer getImageDisplayer() {
 		return imageDisplayer;
 	}
 
 	@Override
 	public void updateValue(IMAGE newImage) {
 		if (analysisMode == AnalysisMode.LOCAL_ANALYSIS) {
 			getImageAnalysisEngine().updateValue(newImage);
 		} else if (analysisMode == AnalysisMode.NO_ANALYSIS) {
 			imageDisplayer.updateValue(newImage);
 		}
 	}
 
 	@Override
 	public void resetForReceiving() {
 		if (analysisMode == AnalysisMode.LOCAL_ANALYSIS) {
 			getImageAnalysisEngine().resetForReceiving();
 		} else if (analysisMode == AnalysisMode.NO_ANALYSIS) {
 			imageDisplayer.resetForReceiving();
 		}
 	}
 
 	/**
 	 * Return true if the popup menu is enabled, otherwise false.
 	 * 
 	 * @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 disabled
 	 */
 	public void setPopupEnabled(boolean enabled) {
 		if (popupEnabled == enabled)
 			return;
 		popupEnabled = enabled;
 		if (enabled) {
 			getImageDisplayer().addMouseListener(getPopupManager().getMouseHook());
 		} else {
 			getImageDisplayer().removeMouseListener(getPopupManager().getMouseHook());
 		}
 		firePropertyChange("popupEnabled", !popupEnabled, popupEnabled);
 	}
 }