/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 *

 */

package com.nokia.carbide.cpp.internal.pi.visual;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.util.ArrayList;

import java.util.Enumeration;

import javax.swing.JDialog;

import org.eclipse.draw2d.FigureCanvas;

import org.eclipse.draw2d.FlowLayout;

import org.eclipse.draw2d.Graphics;

import org.eclipse.draw2d.MouseMotionListener;

import org.eclipse.draw2d.Panel;

import org.eclipse.draw2d.geometry.Point;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.MouseMoveListener;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.graphics.RGB;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.ScrollBar;

import org.eclipse.swt.widgets.Slider;

import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;

import com.nokia.carbide.cpp.internal.pi.analyser.ProfileVisualiser;

import com.nokia.carbide.cpp.internal.pi.analyser.TestGUI;

import com.nokia.carbide.cpp.internal.pi.manager.PluginInitialiser;

import com.nokia.carbide.cpp.internal.pi.plugin.model.IContextMenu;

import com.nokia.carbide.cpp.internal.pi.plugin.model.IEventListener;

import com.nokia.carbide.cpp.pi.editors.PIPageEditor;

import com.nokia.carbide.cpp.pi.util.ColorPalette;

import com.nokia.carbide.cpp.pi.util.GeneralMessages;

public class PICompositePanel implements ActionListener, PIEventListener {

	private SashForm sashForm;

	private Slider slider = null;

	private static final long serialVersionUID = -6350043592270317606L;

	private static final int MOUSE_DOWN = 0;

	private static final int MOUSE_MOVE = 1;

	private static final int MOUSE_DOUBLECLICK = 2;

	private ArrayList<GraphComponentWrapper> graphComponents;

	private ProfileVisualiser profVisu;

	public int lastSampleX = 0;

	private int sizeX = 0;

	private int sizeY = 450;

	private int preferredSizeX = 100000;

	private int preferredSizeY = 0; // this is constant!

	private double selectionStart = -1;

	private double selectionEnd = -1;

	private boolean buttonDown = false;

	private boolean dragOn = false;

	private double origStart = 0;

	private double scale = 10;

	private double previousScale = 10;

	private PIVisualSharedData sharedData;

	JDialog dialog = null;

	SynchroniseDialog dialogPanel = null;

	private GenericTraceGraph activeGraph = null;

	// create a ScrollComposite, with a horizontal scrollbar, containing a

	// sashForm without a scrollbar

	public PICompositePanel(Composite parent,

			ProfileVisualiser profileVisualiser) {

		// all graphs will go into a vertical SashForm

		this.sashForm = new SashForm(parent, SWT.VERTICAL);

		this.sashForm.SASH_WIDTH = 5; // 5 pixel wide sash

		this.sashForm.setLayout(new FillLayout());

		// this.scrolled.setContent(this.sashForm);

		//		

		// // listen for when the horizontal scroll bar is selected

		// final ScrollBar horizontalBar = this.scrolled.getHorizontalBar();

		//

		// horizontalBar.addSelectionListener(new SelectionListener() {

		// public void widgetSelected(SelectionEvent e) {

		// // since other pages associated with the GppTraceGraph scroll when

		// this page scrolls,

		// // also let listening plugins know

		// int ai = AnalysisIdentifier.getIdentifier();

		//        		Enumeration enu = PluginInitialiser.getPluginInstances(ai, "com.nokia.carbide.cpp.internal.pi.plugin.model.IEventListener"); //$NON-NLS-1$

		// if (enu != null) {

		// Event event = new Event();

		// event.x = scrolled.getOrigin().x;

		// event.y = scrolled.getOrigin().y;

		//        			event.data = "FigureCanvas"; //$NON-NLS-1$

		//        			

		// while (enu.hasMoreElements())

		// {

		// IEventListener plugin = (IEventListener)enu.nextElement();

		//            			plugin.receiveEvent("scroll", event); //$NON-NLS-1$

		// }

		// }

		// }

		//

		// public void widgetDefaultSelected(SelectionEvent e) {

		// widgetSelected(e);

		// }

		// });

		//

		// // minor scroll is 10 pixels

		// horizontalBar.setIncrement(10);

		//

		// // major scroll is the width of the window

		// horizontalBar.setPageIncrement(this.scrolled.getBounds().width);

		// this.scrolled.addControlListener(new ControlAdapter()

		// {

		// public void controlResized(ControlEvent e) {

		// horizontalBar.setPageIncrement(scrolled.getBounds().width);

		// }

		// });

		this.graphComponents = new ArrayList<GraphComponentWrapper>();

		this.profVisu = profileVisualiser;

		this.sharedData = new PIVisualSharedData();

	}

	public SashForm getSashForm() {

		return this.sashForm;

	}

	// returns true if the graph needs to be updated (it is either

	// active or visible)

	public boolean hasToBeUpdated(GenericTraceGraph graph) {

		if (graph.getVisualSize().height > 0)

			return true;

		else if (graph.equals(this.getActiveGraph()))

			return true;

		else

			return false;

	}

	// this method adds listeners to graph selections

	private void addMouseListeners(final GraphComponentWrapper wrap,

			FigureCanvas graphCanvas) {

		if (wrap.panel == null)

			return;

		if (wrap.graphComponent instanceof MouseMotionListener) {

			wrap.panel

					.addMouseMotionListener((MouseMotionListener) wrap.graphComponent);

		}

		if (wrap.graphComponent instanceof MouseMoveListener) {

			if (graphCanvas != null)

				graphCanvas

						.addMouseMoveListener((MouseMoveListener) wrap.graphComponent);

		}

		if (wrap.graphComponent instanceof MouseListener) {

			if (graphCanvas != null)

				graphCanvas

						.addMouseListener((MouseListener) wrap.graphComponent);

		}

		if (graphCanvas == null)

			return;

		final FigureCanvas graphCanvasFinal = graphCanvas;

		graphCanvas.addMouseListener(new MouseListener() {

			public void mouseDown(MouseEvent me) {

				// for button 3, show the popup context menu

				if (me.button == 3) // button 3

				{

					final int x = me.x; // don't worry about me.x, this is

										// always a valid coordinate within the

										// panel

					final int y = me.y;

					final MouseEvent meFinal = me;

					Display.getDefault().syncExec(new Runnable() {

						public void run() {

							Menu menu = TestGUI.getInstance()

									.getGraphPopupMenu(

											profVisu.getContentPane()

													.getShell(), true);

							// add submenu items

							addSubGraphMenuItems(menu, meFinal);

							menu.setLocation(graphCanvasFinal.toDisplay(x, y));

						}

					});

					return;

				}

				/*

				 * for other buttons, we may be deleting the current graph

				 * selection or, by dragging, creating a new selection

				 */

				buttonDown = true;

				dragOn = false;

				// me.x will always be a valid coordinate within the Widget,

				// rounded to the nearest millisecond

				// since this is the FigureCanvas, not the Panel, adjust x

				selectionStart = (int) ((me.x + getScrolledOrigin().x) * scale + .0005);

				origStart = selectionStart;

				// send the message to the component under the mouse

				if (me.getSource() instanceof GraphComponentWrapper) {

					GenericTraceGraph source = ((GraphComponentWrapper) me

							.getSource()).getGraphComponent();

					if (source instanceof PIEventListener

							&& hasToBeUpdated(source)) {

						PIEventListener lis = (PIEventListener) source;

						for (int i = 0; i < graphComponents.size(); i++) {

							GenericTraceGraph possible = (GenericTraceGraph) graphComponents

									.get(i).graphComponent;

							if (possible.equals(source)) {

								PIEvent be = new PIEvent(source,

										PIEvent.MOUSE_PRESSED);

								lis.piEventReceived(be);

							}

						}

					}

				}

			}

			public void mouseUp(MouseEvent me) {

				// ignore releases of button 3 (context menu button)

				if (me.button == 3) // button 3

					return;

				// otherwise, either remove the current selection or replace it

				// with a new one

				buttonDown = false;

				if (dragOn) // if dragging was done

				{

					if (selectionStart == selectionEnd) {

						// no range is selected

						selectionStart = -1;

						selectionEnd = -1;

					}

					if (selectionStart < 0 && selectionStart != -1) {

						selectionStart = 0;

					}

					double maxEndTime = PIPageEditor.currentPageEditor()

							.getMaxEndTime() * 1000;

					if (selectionStart > maxEndTime) {

						// no range is selected

						selectionStart = 0;

						selectionEnd = 0;

						profVisu.getTimeString().setText(

								ProfileVisualiser.getTimeInterval(

										selectionStart / 1000,

										selectionEnd / 1000));

					} else if (selectionEnd > maxEndTime) {

						selectionEnd = maxEndTime + .0005;

						profVisu.getTimeString().setText(

								ProfileVisualiser.getTimeInterval(

										selectionStart / 1000,

										selectionEnd / 1000));

					}

					setSelectionFields();

					// inform all subcomponents that the selection area has

					// changed

					PIEvent be = new PIEvent(new double[] { selectionStart,

							selectionEnd }, PIEvent.SELECTION_AREA_CHANGED);

					sendEventToSubComponents(be);

					repaintComponent();

					// since some pages that depend on the selection start and

					// end times may not have

					// graph components (e.g., the function call plugin page),

					// also let listening plugins know

					Enumeration e = PluginInitialiser

							.getPluginInstances(NpiInstanceRepository

									.getInstance().activeUid(),

									"com.nokia.carbide.cpp.internal.pi.plugin.model.IEventListener"); //$NON-NLS-1$

					if (e != null) {

						Event event = new Event();

						event.start = (int) selectionStart;

						event.end = (int) selectionEnd;

						while (e.hasMoreElements()) {

							IEventListener plugin = (IEventListener) e

									.nextElement();

							plugin.receiveEvent("changeSelection", event); //$NON-NLS-1$

						}

					}

					dragOn = false;

				}

			}

			public void mouseDoubleClick(MouseEvent me) {

				sendEventToSubGraphs(PICompositePanel.MOUSE_DOUBLECLICK, me);

				buttonDown = false;

			}

		});

		graphCanvas.addMouseMoveListener(new MouseMoveListener() {

			public void mouseMove(MouseEvent me) {

				int xOrigin = getScrolledOrigin().x;

				me.x += xOrigin;

				if (!buttonDown) {

					sendEventToSubGraphs(PICompositePanel.MOUSE_MOVE, me);

					return;

				}

				// dragging is moving the mouse while a button (other than

				// button 3) is down

				dragOn = true;

				// round to the nearest millisecond

				selectionEnd = (int) (me.x * scale + .0005);

				// mouse event may return out of range X, that may

				// crash when we use it to index data array

				selectionEnd = selectionEnd >= 0 ? selectionEnd : 0;

				if (me.x >= xOrigin + sashForm.getBounds().width) {

					selectionEnd = ((int) ((xOrigin

							+ sashForm.getBounds().width - 1)

							* scale + .0005));

				}

				if (selectionEnd < origStart) // if selection is drawn from

				// right to left

				{

					selectionStart = selectionEnd;

					selectionEnd = origStart;

				} else if (selectionEnd > origStart) {

					selectionStart = origStart;

				}

				setSelectionFields();

				PIPageEditor.currentPageEditor().setLocalTime(

						selectionStart / 1000, selectionEnd / 1000);

				// until mouse button is released, change the time interval

				// display only on this page

				profVisu.getTimeString().setText(

						ProfileVisualiser.getTimeInterval(

								selectionStart / 1000, selectionEnd / 1000));

				drawSelectionRect(me);

				repaintComponent();

				// why is this not in repaintComponent?

				wrap.panel.repaint();

			}

		});

	}

	private void drawSelectionRect(MouseEvent me) {

		if ((me.getSource() == null)

				|| !(me.getSource() instanceof Control/* Panel */))

			return;

		// do not use scrolled.getContent().getBounds() because that is the

		// whole

		// length, not the visable one

		Rectangle rect = this.sashForm.getBounds();

		Point origin = getScrolledOrigin();

		int newX;

		int tmpMeX = me.x;

		// mouse event may return out of range X, that may

		// crash when we use it to index data array

		tmpMeX = tmpMeX >= 0 ? tmpMeX : 0;

		if (tmpMeX >= origin.x + sashForm.getBounds().width) {

			tmpMeX = origin.x + sashForm.getBounds().width - 1;

		}

		if (tmpMeX - origin.x < 20) {

			newX = tmpMeX - 20;

			if (newX < 0)

				newX = 0;

		} else {

			newX = tmpMeX + 20;

		}

		boolean changeOrigin = false;

		// Scroll each of the windows in the ScrolledComposite so that the

		// rectangle is visible

		if (newX < origin.x) {

			// scroll to the left

			this.setScrolledOrigin(newX, origin.y);

			changeOrigin = true;

		} else if (newX > origin.x + rect.width) {

			// scroll to the right

			this.setScrolledOrigin(newX - rect.width, origin.y);

			changeOrigin = true;

		}

		if (changeOrigin) {

			// since other pages associated with the GppTraceGraph scroll when

			// this page scrolls,

			// also let listening plugins know

			Enumeration enu = PluginInitialiser

					.getPluginInstances(NpiInstanceRepository.getInstance()

							.activeUid(),

							"com.nokia.carbide.cpp.internal.pi.plugin.model.IEventListener"); //$NON-NLS-1$

			if (enu != null) {

				origin = getScrolledOrigin();

				Event event = new Event();

				event.x = origin.x;

				event.y = origin.y;

				event.data = "FigureCanvas"; //$NON-NLS-1$

				while (enu.hasMoreElements()) {

					IEventListener plugin = (IEventListener) enu.nextElement();

					plugin.receiveEvent("scroll", event); //$NON-NLS-1$

				}

			}

		}

	}

	public PIVisualSharedData getSharedData() {

		return this.sharedData;

	}

	public void setToolTipTextForGraphComponent(GenericTraceGraph graph,

			String text) {

		if (this.graphComponents != null) {

			for (int i = 0; i < graphComponents.size(); i++) {

				GraphComponentWrapper wrap = graphComponents.get(i);

				if (wrap.graphComponent.equals(graph)) {

					wrap.figureCanvas.setToolTipText(text);

				}

			}

		}

	}

	public void setScrolledOrigin(int x, int y) {

		if (this.graphComponents != null) {

			for (int i = 0; i < graphComponents.size(); i++) {

				FigureCanvas figureCanvas = graphComponents.get(i).figureCanvas;

				if (figureCanvas == null)

					continue;

				figureCanvas.getViewport().setViewLocation(x, y);

				if (figureCanvas.getViewport().getViewLocation().x != x) {

					// force the viewport to accept the new value

					figureCanvas.getViewport().getHorizontalRangeModel()

							.setMaximum(this.sizeX);

					figureCanvas.getViewport().setViewLocation(x, y);

				}

			}

		}

	}

	public Point getScrolledOrigin() {

		// this assumes that setScrolledOrigin() is keeping all graphs scrolled

		// the same amount

		if (this.graphComponents == null)

			return null;

		else

			return graphComponents.get(0).figureCanvas.getViewport()

					.getViewLocation();

	}

	public void setCurrentInfoComponent(Component currentComponent) {

		this.profVisu.vPanelRepaint(currentComponent);

	}

	private void sendEventToSubGraphs(int type, MouseEvent me) {

		FigureCanvas figureCanvas;

		GraphComponentWrapper component = null;

		if (!(me.getSource() instanceof FigureCanvas))

			return;

		figureCanvas = (FigureCanvas) me.getSource();

		// find the component whose FigureCanvas this is

		for (int i = 0; i < this.graphComponents.size(); i++)

			if (this.graphComponents.get(i).figureCanvas == figureCanvas) {

				component = this.graphComponents.get(i);

				break;

			}

		if (component == null)