analysis: Move plugins to their own sub-directory

[deliverable/tracecompass.git] / org.eclipse.tracecompass.tmf.ui / src / org / eclipse / tracecompass / tmf / ui / views / uml2sd / SDWidget.java

/**********************************************************************
 * Copyright (c) 2005, 2014 IBM Corporation, Ericsson
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM - Initial API and implementation
 *     Bernd Hufmann - Updated for TMF
 **********************************************************************/

package org.eclipse.tracecompass.tmf.ui.views.uml2sd;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import org.eclipse.jface.contexts.IContextIds;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.ACC;
import org.eclipse.swt.accessibility.Accessible;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleControlAdapter;
import org.eclipse.swt.accessibility.AccessibleControlEvent;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.printing.Printer;
import org.eclipse.swt.printing.PrinterData;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Caret;
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.Listener;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.tracecompass.internal.tmf.ui.Activator;
import org.eclipse.tracecompass.internal.tmf.ui.ITmfImageConstants;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.BaseMessage;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.BasicExecutionOccurrence;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Frame;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.GraphNode;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.ITimeRange;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Lifeline;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Metrics;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.dialogs.SDPrintDialog;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.dialogs.SDPrintDialogUI;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.drawings.IColor;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.handlers.provider.ISDCollapseProvider;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.load.LoadersManager;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.preferences.ISDPreferences;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.preferences.SDViewPref;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.util.Messages;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.part.ViewPart;

/**
 * <p>
 * This class implements sequence diagram widget used in the sequence diagram view.
 * </p>
 *
 * @version 1.0
 * @author sveyrier
 */
public class SDWidget extends ScrollView implements SelectionListener,
        IPropertyChangeListener, DisposeListener, ITimeCompressionListener {

    // ------------------------------------------------------------------------
    // Attributes
    // ------------------------------------------------------------------------

    /**
     * The frame to display in the sequence diagram widget.
     */
    private Frame fFrame;
    /**
     * The overview image to display.
     */
    private Image fOverView = null;
    /**
     * The zoom in menu item.
     */
    private MenuItem fZoomIn = null;
    /**
     * The zoom out menu item.
     */
    private MenuItem fZoomOut = null;
    /**
     * The sequence diagram selection provider.
     */
    private SDWidgetSelectionProvider fSelProvider = null;
    /**
     * The current zoom value.
     */
    private float fZoomValue = 1;
    /**
     * The current zoomInMode (true for zoom in).
     */
    private boolean fZoomInMode = false;
    /**
     * The current zoomOutMode (true for zoom out).
     */
    private boolean fZoomOutMode = false;
    /**
     * The current list of selected graph nodes.
     */
    private List<GraphNode> fSelectedNodeList = null;
    /**
     * Flag whether ctrl button is selected or not.
     */
    private boolean fCtrlSelection = false;
    /**
     * A reference to the view site.
     */
    private ViewPart fSite = null;
    /**
     * The current graph node (the last selected one).
     */
    private GraphNode fCurrentGraphNode = null;
    /**
     * The first graph node in list (multiple selection).
     */
    private GraphNode fListStart = null;
    /**
     * The previous graph node (multiple selection).
     */
    private List<GraphNode> fPrevList = null;
    /**
     * The time compression bar.
     */
    private TimeCompressionBar fTimeBar = null;
    /**
     * The current diagram tool tip.
     */
    private DiagramToolTip fToolTip = null;
    /**
     * The accessible object reference of view control.
     */
    private Accessible fAccessible = null;
    /**
     * The current node for the tooltip to display.
     */
    private GraphNode fToolTipNode;
    /**
     * The life line to drag and drop.
     */
    private Lifeline fDragAndDrop = null;
    /**
     * The number of focused widgets.
     */
    private int fFocusedWidget = -1;
    /**
     * The printer zoom.
     */
    private float fPrinterZoom = 0;
    /**
     * Y coordinate for printer.
     */
    private int fPrinterY = 0;
    /**
     * X coordinate for printer.
     */
    private int fPrinterX = 0;
    /**
     * Flag whether drag and drop is enabled or not.
     */
    private boolean fIsDragAndDrop = false;
    /**
     * The x coordinate for drag.
     */
    private int fDragX = 0;
    /**
     * The y coordinate for drag.
     */
    private int fDragY = 0;
    /**
     * The reorder mode.
     */
    private boolean fReorderMode = false;
    /**
     * The collapse caret image.
     */
    private Image fCollapaseCaretImg = null;
    /**
     * The arrow up caret image.
     */
    private Image fArrowUpCaretImg = null;
    /**
     * The current caret image.
     */
    private Image fCurrentCaretImage = null;
    /**
     * A sequence diagramm collapse provider (for collapsing graph nodes)
     */
    private ISDCollapseProvider fCollapseProvider = null;
    /**
     * The insertion caret.
     */
    private Caret fInsertionCartet = null;
    /**
     * The reorder list when in reorder mode.
     */
    private List<Lifeline[]> fReorderList = null;
    /**
     * Flag to specify whether in printing mode or not.
     */
    private boolean fIsPrinting = false;
    /**
     * A printer reference.
     */
    private Printer fPrinter = null;
    /**
     * Flag whether shift was selected or not.
     */
    private boolean fShiftSelection = false;
    /**
     * The scroll tooltip.
     */
    private DiagramToolTip fScrollToolTip = null;
    /**
     * Timer for auto_scroll feature
     */
    private AutoScroll fLocalAutoScroll = null;
    /**
     * TimerTask for auto_scroll feature !=null when auto scroll is running
     */
    private Timer fLocalAutoScrollTimer = null;

    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    /**
     * Constructor for SDWidget.
     * @param c The parent composite
     * @param s The style
     */
    public SDWidget(Composite c, int s) {
        super(c, s | SWT.NO_BACKGROUND, true);
        setOverviewEnabled(true);
        fSelectedNodeList = new ArrayList<>();
        fSelProvider = new SDWidgetSelectionProvider();
        SDViewPref.getInstance().addPropertyChangeListener(this);
        fToolTip = new DiagramToolTip(getViewControl());
        super.addDisposeListener(this);

        fScrollToolTip = new DiagramToolTip(c);
        getVerticalBar().addListener(SWT.MouseUp, new Listener() {

            @Override
            public void handleEvent(Event event) {
                fScrollToolTip.hideToolTip();
            }

        });
        fAccessible = getViewControl().getAccessible();

        fAccessible.addAccessibleListener(new AccessibleAdapter() {
            @Override
            public void getName(AccessibleEvent e) {
                // Case toolTip
                if (e.childID == 0) {
                    if (fToolTipNode != null) {
                        if (fToolTipNode instanceof Lifeline) {
                            Lifeline lifeline = (Lifeline) fToolTipNode;
                            e.result = lifeline.getToolTipText();
                        } else {
                            e.result = fToolTipNode.getName() + getPostfixForTooltip(true);
                        }
                    }
                } else {
                    if (getFocusNode() != null) {
                        if (getFocusNode() instanceof Lifeline) {
                            e.result = MessageFormat.format(Messages.SequenceDiagram_LifelineNode, new Object[] { String.valueOf(getFocusNode().getName()) });
                        }
                        if (getFocusNode() instanceof BaseMessage) {
                            BaseMessage mes = (BaseMessage) getFocusNode();
                            if ((mes.getStartLifeline() != null) && (mes.getEndLifeline() != null)) {
                                e.result = MessageFormat.format(
                                        Messages.SequenceDiagram_MessageNode,
                                        new Object[] { String.valueOf(mes.getName()), String.valueOf(mes.getStartLifeline().getName()), Integer.valueOf(mes.getStartOccurrence()), String.valueOf(mes.getEndLifeline().getName()),
                                                Integer.valueOf(mes.getEndOccurrence()) });
                            } else if ((mes.getStartLifeline() == null) && (mes.getEndLifeline() != null)) {
                                e.result = MessageFormat.format(Messages.SequenceDiagram_FoundMessageNode, new Object[] { String.valueOf(mes.getName()), String.valueOf(mes.getEndLifeline().getName()), Integer.valueOf(mes.getEndOccurrence()) });
                            } else if ((mes.getStartLifeline() != null) && (mes.getEndLifeline() == null)) {
                                e.result = MessageFormat.format(Messages.SequenceDiagram_LostMessageNode, new Object[] { String.valueOf(mes.getName()), String.valueOf(mes.getStartLifeline().getName()), Integer.valueOf(mes.getStartOccurrence()) });
                            }
                        } else if (getFocusNode() instanceof BasicExecutionOccurrence) {
                            BasicExecutionOccurrence exec = (BasicExecutionOccurrence) getFocusNode();
                            e.result = MessageFormat.format(Messages.SequenceDiagram_ExecutionOccurrenceWithParams,
                                    new Object[] { String.valueOf(exec.getName()), String.valueOf(exec.getLifeline().getName()), Integer.valueOf(exec.getStartOccurrence()), Integer.valueOf(exec.getEndOccurrence()) });
                        }

                    }
                }
            }
        });

        fAccessible.addAccessibleControlListener(new AccessibleControlAdapter() {
            @Override
            public void getFocus(AccessibleControlEvent e) {
                if (fFocusedWidget == -1) {
                    e.childID = ACC.CHILDID_SELF;
                } else {
                    e.childID = fFocusedWidget;
                }
            }

            @Override
            public void getRole(AccessibleControlEvent e) {
                switch (e.childID) {
                case ACC.CHILDID_SELF:
                    e.detail = ACC.ROLE_CLIENT_AREA;
                    break;
                case 0:
                    e.detail = ACC.ROLE_TOOLTIP;
                    break;
                case 1:
                    e.detail = ACC.ROLE_LABEL;
                    break;
                default:
                    break;
                }
            }

            @Override
            public void getState(AccessibleControlEvent e) {
                e.detail = ACC.STATE_FOCUSABLE;
                if (e.childID == ACC.CHILDID_SELF) {
                    e.detail |= ACC.STATE_FOCUSED;
                } else {
                    e.detail |= ACC.STATE_SELECTABLE;
                    if (e.childID == fFocusedWidget) {
                        e.detail |= ACC.STATE_FOCUSED | ACC.STATE_SELECTED | ACC.STATE_CHECKED;
                    }
                }
            }
        });

        fInsertionCartet = new Caret((Canvas) getViewControl(), SWT.NONE);
        fInsertionCartet.setVisible(false);

        fCollapaseCaretImg = Activator.getDefault().getImageFromPath(ITmfImageConstants.IMG_UI_ARROW_COLLAPSE_OBJ);
        fArrowUpCaretImg = Activator.getDefault().getImageFromPath(ITmfImageConstants.IMG_UI_ARROW_UP_OBJ);

        fReorderList = new ArrayList<>();
        getViewControl().addTraverseListener(new LocalTraverseListener());

        addTraverseListener(new LocalTraverseListener());

        getViewControl().addFocusListener(new FocusListener() {

            @Override
            public void focusGained(FocusEvent e) {
                SDViewPref.getInstance().setNoFocusSelection(false);
                fCtrlSelection = false;
                fShiftSelection = false;
                redraw();
            }

            @Override
            public void focusLost(FocusEvent e) {
                SDViewPref.getInstance().setNoFocusSelection(true);
                redraw();
            }
        });
    }

    // ------------------------------------------------------------------------
    // Operations
    // ------------------------------------------------------------------------

    /**
     * Sets the time compression bar.
     *
     * @param bar The time compression bar to set
     */
    public void setTimeBar(TimeCompressionBar bar) {
        if (bar != null) {
            fTimeBar = bar;
            fTimeBar.addTimeCompressionListener(this);
        }
    }

    /**
     * Resize the contents to insure the frame fit into the view
     *
     * @param frame the frame which will be drawn in the view
     */
    public void resizeContents(Frame frame) {
        int width = Math.round((frame.getWidth() + 2 * Metrics.FRAME_H_MARGIN) * fZoomValue);
        int height = Math.round((frame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);
        resizeContents(width, height);
    }

    /**
     * The frame to render (the sequence diagram)
     *
     * @param theFrame the frame to display
     * @param resetPosition boolean
     */
    public void setFrame(Frame theFrame, boolean resetPosition) {
        fReorderList.clear();
        fSelectedNodeList.clear();
        fSelProvider.setSelection(new StructuredSelection());
        fFrame = theFrame;
        if (resetPosition) {
            setContentsPos(0, 0);
            resizeContents(fFrame);
            redraw();
        }
        // prepare the old overview to be reused
        if (fOverView != null) {
            fOverView.dispose();
        }
        fOverView = null;
        resizeContents(fFrame);
    }

    /**
     * Returns the current Frame (the sequence diagram container)
     *
     * @return the frame
     */
    public Frame getFrame() {
        return fFrame;
    }

    /**
     * Returns the selection provider for the current sequence diagram
     *
     * @return the selection provider
     */
    public ISelectionProvider getSelectionProvider() {
        return fSelProvider;
    }

    /**
     * Returns a list of selected graph nodes.
     *
     * @return a list of selected graph nodes.
     */
    public List<GraphNode> getSelection() {
        return fSelectedNodeList;
    }

    /**
     * Adds a graph node to the selected nodes list.
     *
     * @param node A graph node
     */
    public void addSelection(GraphNode node) {
        if (node == null) {
            return;
        }
        fSelectedNodeList.add(node);
        node.setSelected(true);
        fCurrentGraphNode = node;
        StructuredSelection selection = new StructuredSelection(fSelectedNodeList);
        fSelProvider.setSelection(selection);
    }

    /**
     * Adds a list of node to the selected nodes list.
     *
     * @param list of graph nodes
     */
    public void addSelection(List<GraphNode> list) {
        for (int i = 0; i < list.size(); i++) {
            if (!fSelectedNodeList.contains(list.get(i))) {
                fSelectedNodeList.add(list.get(i));
                list.get(i).setSelected(true);
            }
        }
        StructuredSelection selection = new StructuredSelection(fSelectedNodeList);
        fSelProvider.setSelection(selection);
    }

    /**
     * Removes a node from the selected nodes list.
     *
     * @param node to remove
     */
    public void removeSelection(GraphNode node) {
        fSelectedNodeList.remove(node);
        node.setSelected(false);
        node.setFocused(false);
        StructuredSelection selection = new StructuredSelection(fSelectedNodeList);
        fSelProvider.setSelection(selection);
    }

    /**
     * Removes a list of graph nodes from the selected nodes list.
     *
     * @param list of nodes to remove.
     */
    public void removeSelection(List<GraphNode> list) {
        fSelectedNodeList.removeAll(list);
        for (int i = 0; i < list.size(); i++) {
            list.get(i).setSelected(false);
            list.get(i).setFocused(false);
        }
        StructuredSelection selection = new StructuredSelection(fSelectedNodeList);
        fSelProvider.setSelection(selection);
    }

    /**
     * Clear the list of GraphNodes which must be drawn selected.
     */
    public void clearSelection() {
        for (int i = 0; i < fSelectedNodeList.size(); i++) {
            fSelectedNodeList.get(i).setSelected(false);
            fSelectedNodeList.get(i).setFocused(false);
        }
        fCurrentGraphNode = null;
        fSelectedNodeList.clear();
        fSelProvider.setSelection(new StructuredSelection());
    }

    /**
     * Sets view part.
     *
     * @param viewSite The view part to set
     */
    public void setSite(ViewPart viewSite) {
        fSite = viewSite;
        fSite.getSite().setSelectionProvider(fSelProvider);
        Object serviceObject = fSite.getSite().getWorkbenchWindow().getService(IContextService.class);
        IContextService service = (IContextService) serviceObject;
        service.activateContext("org.eclipse.linuxtools.tmf.ui.view.uml2sd.context"); //$NON-NLS-1$
        service.activateContext(IContextIds.CONTEXT_ID_WINDOW);
    }

    /**
     * Returns the GraphNode overView the mouse if any
     *
     * @return the current graph node
     * */
    public GraphNode getMouseOverNode() {
        return fCurrentGraphNode;
    }

    /**
     * Sets the zoom in mode.
     *
     * @param value
     *            The mode value to set.
     */
    public void setZoomInMode(boolean value) {
        if (value) {
            setZoomOutMode(false);
        }
        fZoomInMode = value;
    }

    /**
     * Sets the zoom out mode.
     *
     * @param value
     *          The mode value to set.
     */
    public void setZoomOutMode(boolean value) {
        if (value) {
            setZoomInMode(false);
        }
        fZoomOutMode = value;
    }

    /**
     * Sets the current zoom value.
     *
     * @param zoomValue
     *          The current zoom value
     */
    public void setZoomValue(float zoomValue) {
        fZoomValue = zoomValue;
    }

    /**
     * Moves the Sequence diagram to ensure the given node is visible and draw it selected
     *
     * @param node the GraphNode to move to
     */
    public void moveTo(GraphNode node) {
        if (node == null) {
            return;
        }
        clearSelection();
        addSelection(node);
        ensureVisible(node);
    }

    /**
     * Moves the Sequence diagram to ensure the given node is visible
     *
     * @param node the GraphNode to move to
     */
    public void ensureVisible(GraphNode node) {
        if (node == null) {
            return;
        }
        int x = Math.round(node.getX() * fZoomValue);
        int y = Math.round(node.getY() * fZoomValue);
        int width = Math.round(node.getWidth() * fZoomValue);
        int height = Math.round(node.getHeight() * fZoomValue);
        if ((node instanceof BaseMessage) && (height == 0)) {
            int header = Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN * 2 + Metrics.getLifelineHeaderFontHeigth();
            height = -Math.round((Metrics.getMessagesSpacing() + header) * fZoomValue);
            y = y + Math.round(Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT * fZoomValue);
        }
        if (node instanceof BasicExecutionOccurrence) {
            width = 1;
            height = 1;
        }
        if (node instanceof Lifeline) {
            y = getContentsY();
            height = getVisibleHeight();
        }
        ensureVisible(x, y, width, height, SWT.CENTER, true);
        redraw();
    }

    /**
     * Returns the current zoom factor.
     * @return the current zoom factor.
     */
    public float getZoomFactor() {
        return fZoomValue;
    }

    /**
     * Returns teh printer reference.
     *
     * @return the printer reference
     */
    public Printer getPrinter() {
        return fPrinter;
    }

    /**
     * Returns whether the widget is used for printing or not.
     *
     * @return whether the widget is used for printing or not
     */
    public boolean isPrinting() {
        return fIsPrinting;
    }

    /**
     * Returns the current graph node.
     *
     * @return the current graph node
     */
    public GraphNode getCurrentGraphNode() {
        return fCurrentGraphNode;
    }

    /**
     * Returns the current zoom value.
     *
     * @return the current zoom value
     */
    public float getZoomValue() {
        return fZoomValue;
    }

    /**
     * Gets the zoom in mode.
     *
     * @return the mode value to set.
     */
    public boolean getZoomInMode() {
        return fZoomInMode;
    }


    /**
     * Gets the zoom out mode.
     *
     * @return the mode value to set.
     */
    public boolean getZoomOutMode() {
        return fZoomOutMode;
    }

    /**
     * Returns if ctrl selection
     * @return true if ctrl selection else false
     */
    public boolean isCtrlSelection() {
        return fCtrlSelection;
    }

    /**
     * Returns if shift selection
     * @return true if shift Selection else false
     */
    public boolean isShiftSelection() {
        return fCtrlSelection;
    }

    /**
     * Gets the overview image.
     *
     * @param rect Rectangle to include overview.
     * @return the overview image
     */
    public Image getOverview(Rectangle rect) {
        float oldzoom = fZoomValue;
        if ((fOverView != null) && ((rect.width != fOverView.getBounds().width) || (rect.height != fOverView.getBounds().height))) {
            fOverView.dispose();
            fOverView = null;
        }
        if (fOverView == null) {
            int backX = getContentsX();
            int backY = getContentsY();
            setContentsPos(0, 0);
            fOverView = new Image(getDisplay(), rect.width, rect.height);
            GC gcim = new GC(fOverView);
            NGC context = new NGC(this, gcim);
            context.setBackground(SDViewPref.getInstance().getBackGroundColor(ISDPreferences.PREF_FRAME));
            fFrame.draw(context);
            setContentsPos(backX, backY);
            gcim.dispose();
            context.dispose();
        }
        fZoomValue = oldzoom;
        return fOverView;
    }

    /**
     * Resets the zoom factor.
     */
    public void resetZoomFactor() {
        int currentX = Math.round(getContentsX() / fZoomValue);
        int currentY = Math.round(getContentsY() / fZoomValue);
        fZoomValue = 1;
        if (fTimeBar != null && !fTimeBar.isDisposed()) {
            fTimeBar.setZoom(fZoomValue);
        }
        redraw();
        update();
        setContentsPos(currentX, currentY);
    }

    /**
     * Enable or disable the lifeline reodering using Drag and Drop
     *
     * @param mode - true to enable false otherwise
     */
    public void setReorderMode(boolean mode) {
        fReorderMode = mode;
    }

    /**
     * Return the lifelines reorder sequence (using Drag and Drop) if the the reorder mode is turn on. Each ArryList
     * element is of type Lifeline[2] with Lifeline[0] inserted before Lifeline[1] in the diagram
     *
     * @return - the re-odered sequence
     */
    public List<Lifeline[]> getLifelineReoderList() {
        return fReorderList;
    }

    /**
     * Sets the focus on given graph node (current node).
     *
     * @param node
     *            The graph node to focus on.
     */
    public void setFocus(GraphNode node) {
        if (node == null) {
            return;
        }
        if (fCurrentGraphNode != null) {
            fCurrentGraphNode.setFocused(false);
        }
        fCurrentGraphNode = node;
        node.setFocused(true);
        ensureVisible(node);
        setFocus(0);
    }

    /**
     * Returns the graph node focused on.
     *
     * @return the current graph node
     */
    public GraphNode getFocusNode() {
        return fCurrentGraphNode;
    }

    /**
     * Method to traverse right.
     */
    public void traverseRight() {
        Object selectedNode = getFocusNode();
        if (selectedNode == null) {
            traverseLeft();
        }
        GraphNode node = null;
        if ((selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getEndLifeline() != null)) {
            node = fFrame.getCalledMessage((BaseMessage) selectedNode);
        }
        if (selectedNode instanceof BasicExecutionOccurrence) {
            selectedNode = ((BasicExecutionOccurrence) selectedNode).getLifeline();
        }
        if ((node == null) && (selectedNode instanceof Lifeline)) {
            for (int i = 0; i < fFrame.lifeLinesCount(); i++) {
                if ((selectedNode == fFrame.getLifeline(i)) && (i < fFrame.lifeLinesCount() - 1)) {
                    node = fFrame.getLifeline(i + 1);
                    break;
                }
            }
        }
        if (node != null) {
            setFocus(node);
            redraw();
        }
    }

    /**
     * Method to traverse left.
     */
    public void traverseLeft() {
        Object selectedNode = getFocusNode();
        GraphNode node = null;
        if ((selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getStartLifeline() != null)) {
            node = fFrame.getCallerMessage((BaseMessage) selectedNode);
        }
        if (selectedNode instanceof BasicExecutionOccurrence) {
            selectedNode = ((BasicExecutionOccurrence) selectedNode).getLifeline();
        }
        if (node == null) {
            if ((selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getEndLifeline() != null)) {
                selectedNode = ((BaseMessage) selectedNode).getEndLifeline();
            }
            for (int i = 0; i < fFrame.lifeLinesCount(); i++) {
                if ((selectedNode == fFrame.getLifeline(i)) && (i > 0)) {
                    node = fFrame.getLifeline(i - 1);
                    break;
                }
            }
            if ((fFrame.lifeLinesCount() > 0) && (node == null)) {
                node = fFrame.getLifeline(0);
            }
        }
        if (node != null) {
            setFocus(node);
            redraw();
        }
    }

    /**
     * Method to traverse up.
     */
    public void traverseUp() {
        Object selectedNode = getFocusNode();
        if (selectedNode == null) {
            traverseLeft();
        }
        GraphNode node = null;
        if (selectedNode instanceof BaseMessage) {
            node = fFrame.getPrevLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), (BaseMessage) selectedNode);
        } else if (selectedNode instanceof Lifeline) {
            node = fFrame.getPrevLifelineMessage((Lifeline) selectedNode, null);
            if (!(node instanceof Lifeline)) {
                node = null;
            }
        } else if (selectedNode instanceof BasicExecutionOccurrence) {
            node = fFrame.getPrevExecOccurrence((BasicExecutionOccurrence) selectedNode);
            if (node == null) {
                node = ((BasicExecutionOccurrence) selectedNode).getLifeline();
            }
        }
        if ((node == null) && (selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getStartLifeline() != null)) {
            node = ((BaseMessage) selectedNode).getStartLifeline();
        }

        if (node != null) {
            setFocus(node);
            redraw();
        }
    }

    /**
     * Method to traverse down.
     */
    public void traverseDown() {
        Object selectedNode = getFocusNode();
        if (selectedNode == null) {
            traverseLeft();
        }
        GraphNode node;
        if (selectedNode instanceof BaseMessage) {
            node = fFrame.getNextLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), (BaseMessage) selectedNode);
        } else if (selectedNode instanceof Lifeline) {
            node = fFrame.getFirstExecution((Lifeline) selectedNode);
        } else if (selectedNode instanceof BasicExecutionOccurrence) {
            node = fFrame.getNextExecOccurrence((BasicExecutionOccurrence) selectedNode);
        } else {
            return;
        }

        if (node != null) {
            setFocus(node);
            redraw();
        }
    }

    /**
     * Method to traverse home.
     */
    public void traverseHome() {
        Object selectedNode = getFocusNode();
        if (selectedNode == null) {
            traverseLeft();
        }
        GraphNode node = null;

        if (selectedNode instanceof BaseMessage) {
            if (((BaseMessage) selectedNode).getStartLifeline() != null) {
                node = fFrame.getNextLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), null);
            } else {
                node = fFrame.getNextLifelineMessage(((BaseMessage) selectedNode).getEndLifeline(), null);
            }
        } else if (selectedNode instanceof Lifeline) {
            node = fFrame.getNextLifelineMessage((Lifeline) selectedNode, null);
        } else if (selectedNode instanceof BasicExecutionOccurrence) {
            node = fFrame.getFirstExecution(((BasicExecutionOccurrence) selectedNode).getLifeline());
        } else {
            if (fFrame.lifeLinesCount() > 0) {
                Lifeline lifeline = fFrame.getLifeline(0);
                node = fFrame.getNextLifelineMessage(lifeline, null);
            }
        }

        if (node != null) {
            setFocus(node);
            redraw();
        }
    }

    /**
     * Method to traverse to the end.
     */
    public void traverseEnd() {
        Object selectedNode = getFocusNode();
        if (selectedNode == null) {
            traverseLeft();
        }
        GraphNode node;
        if (selectedNode instanceof BaseMessage) {
            node = fFrame.getPrevLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), null);
        } else if (selectedNode instanceof Lifeline) {
            node = fFrame.getPrevLifelineMessage((Lifeline) selectedNode, null);
        } else if (selectedNode instanceof BasicExecutionOccurrence) {
            node = fFrame.getLastExecOccurrence(((BasicExecutionOccurrence) selectedNode).getLifeline());
        } else {
            if (fFrame.lifeLinesCount() > 0) {
                Lifeline lifeline = fFrame.getLifeline(0);
                node = fFrame.getPrevLifelineMessage(lifeline, null);
            } else {
                return;
            }
        }

        if (node != null) {
            setFocus(node);
            redraw();
        }
    }

    /**
     * Method to print UI.
     *
     * @param sdPrintDialog the sequence diagram printer dialog.
     */
    public void printUI(SDPrintDialogUI sdPrintDialog) {
        PrinterData data = sdPrintDialog.getPrinterData();

        if ((data == null) || (fFrame == null)) {
            return;
        }

        fPrinter = new Printer(data);

        String jobName = MessageFormat.format(Messages.SequenceDiagram_plus, new Object[] { String.valueOf(fSite.getContentDescription()), String.valueOf(fFrame.getName()) });
        fPrinter.startJob(jobName);

        GC gc = new GC(fPrinter);

        float lastZoom = fZoomValue;

        Rectangle area = getClientArea();
        GC gcim = null;

        gcim = gc;
        NGC context = new NGC(this, gcim);

        // Set the metrics to use for lifeline text and message text
        // using the Graphical Context
        Metrics.setLifelineFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE)));
        Metrics.setLifelineFontWidth(context.getFontWidth(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE)));
        Metrics.setLifelineWidth(SDViewPref.getInstance().getLifelineWidth());
        Metrics.setFrameFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_FRAME_NAME)));
        Metrics.setLifelineHeaderFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE_HEADER)));

        int syncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_SYNC_MESS));
        int syncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_SYNC_MESS_RET));
        int asyncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_ASYNC_MESS));
        int asyncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_ASYNC_MESS_RET));

        int messageFontHeight = 0;
        if (syncMessFontH > syncMessRetFontH) {
            messageFontHeight = syncMessFontH;
        } else {
            messageFontHeight = syncMessRetFontH;
        }
        if (messageFontHeight < asyncMessFontH) {
            messageFontHeight = asyncMessFontH;
        }
        if (messageFontHeight < asyncMessRetFontH) {
            messageFontHeight = asyncMessRetFontH;
        }
        Metrics.setMessageFontHeight(messageFontHeight);
        context.setFont(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE));

        int width = Math.round((fFrame.getWidth() + 2 * Metrics.FRAME_H_MARGIN) * fZoomValue);
        int height = Math.round((fFrame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);
        if (width < area.width) {
            width = area.width;
        }
        if (height < area.height) {
            height = area.height;
        }
        resizeContents(width, height);

        context.setBackground(SDViewPref.getInstance().getBackGroundColor(ISDPreferences.PREF_FRAME));
        context.fillRectangle(0, 0, getContentsWidth(), Metrics.FRAME_V_MARGIN);
        context.fillRectangle(0, 0, fFrame.getX(), getContentsHeight());
        context.fillRectangle(fFrame.getX() + fFrame.getWidth() + 1, 0, getContentsWidth() - (fFrame.getX() + fFrame.getWidth() + 1), getContentsHeight());
        context.fillRectangle(0, fFrame.getY() + fFrame.getHeight() + 1, getContentsWidth(), getContentsHeight() - (fFrame.getY() + fFrame.getHeight() + 1));
        gcim.setLineWidth(1);

        fPrinter.startPage();
        fZoomValue = lastZoom;

        int restoreX = getContentsX();
        int restoreY = getContentsY();

        float zh = sdPrintDialog.getStepY() * sdPrintDialog.getZoomFactor();
        float zw = sdPrintDialog.getStepX() * sdPrintDialog.getZoomFactor();

        float zoomValueH = fPrinter.getClientArea().height / zh;
        float zoomValueW = fPrinter.getClientArea().width / zw;
        if (zoomValueH > zoomValueW) {
            fPrinterZoom = zoomValueH;
        } else {
            fPrinterZoom = zoomValueW;
        }

        if (sdPrintDialog.printSelection()) {
            int[] pagesList = sdPrintDialog.getPageList();

            for (int pageIndex = 0; pageIndex < pagesList.length; pageIndex++) {
                printPage(pagesList[pageIndex], sdPrintDialog, context);
            }
        } else if (sdPrintDialog.printAll()) {
            for (int pageIndex = 1; pageIndex <= sdPrintDialog.maxNumOfPages(); pageIndex++) {
                printPage(pageIndex, sdPrintDialog, context);
            }
        } else if (sdPrintDialog.printCurrent()) {
            printPage(getContentsX(), getContentsY(), sdPrintDialog, context, 1);
        } else if (sdPrintDialog.printRange()) {
            for (int pageIndex = sdPrintDialog.getFrom(); pageIndex <= sdPrintDialog.maxNumOfPages() && pageIndex <= sdPrintDialog.getTo(); pageIndex++) {
                printPage(pageIndex, sdPrintDialog, context);
            }
        }

        fPrinter.endJob();
        fIsPrinting = false;

        gc.dispose();
        context.dispose();

        fZoomValue = lastZoom;
        fPrinter.dispose();
        setContentsPos(restoreX, restoreY);
    }

    /**
     * Method to print.
     */
    public void print() {
        SDPrintDialog sdPrinter = new SDPrintDialog(this.getShell(), this);
        try {
            if (sdPrinter.open() != 0) {
                return;
            }
        } catch (Exception e) {
            Activator.getDefault().logError("Error creating image", e); //$NON-NLS-1$
            return;
        }
        printUI(sdPrinter.getDialogUI());
    }

    /**
     * Method to print a page.
     *
     * @param pageNum The page number
     * @param pd The sequence diagram print dialog
     * @param context The graphical context
     */
    public void printPage(int pageNum, SDPrintDialogUI pd, NGC context) {
        int j = pageNum / pd.getNbRow();
        int i = pageNum % pd.getNbRow();
        if (i != 0) {
            j++;
        } else {
            i = pd.getNbRow();
        }

        i--;
        j--;

        i = (int) (i * pd.getStepX());
        j = (int) (j * pd.getStepY());

        printPage(i, j, pd, context, pageNum);

        fPrinter.endPage();
    }

    /**
     * Method to print page ranges.
     *
     * @param i
     *            The start page
     * @param j
     *            The end page
     * @param pd
     *            The sequence diagram print dialog
     * @param context
     *            The graphical context
     * @param pageNum
     *            The current page
     */
    public void printPage(int i, int j, SDPrintDialogUI pd, NGC context, int pageNum) {
        fIsPrinting = false;
        int pageNumFontZoom = fPrinter.getClientArea().height / getVisibleHeight();
        fPrinterX = i;
        fPrinterY = j;
        setContentsPos(i, j);
        update();
        fIsPrinting = true;
        float lastZoom = fZoomValue;
        fZoomValue = fPrinterZoom * lastZoom;

        fFrame.draw(context);

        fZoomValue = pageNumFontZoom;
        context.setFont(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE));
        String currentPageNum = String.valueOf(pageNum);
        int ii = context.textExtent(currentPageNum);
        int jj = context.getCurrentFontHeight();
        fZoomValue = fPrinterZoom * lastZoom;
        context.drawText(currentPageNum, Math.round(fPrinterX + getVisibleWidth() / fPrinterZoom - ii / fPrinterZoom), Math.round(fPrinterY + getVisibleHeight() / fPrinterZoom - jj / fPrinterZoom), false);
        fIsPrinting = false;
        fZoomValue = lastZoom;
    }

    /**
     * Sets the collapse provider.
     *
     * @param provider The collapse provider to set
     */
    protected void setCollapseProvider(ISDCollapseProvider provider) {
        fCollapseProvider = provider;
    }


    /**
     * Checks for focus of children.
     *
     * @param children Control to check
     * @return true if child is on focus else false
     */
    protected boolean checkFocusOnChilds(Control children) {
        if (children instanceof Composite) {
            Control[] child = ((Composite) children).getChildren();
            for (int i = 0; i < child.length; i++) {
                if (child[i].isFocusControl()) {
                    return true;
                }
                checkFocusOnChilds(child[i]);
            }
        }
        return false;
    }

    /**
     * A post action for a tooltip (before displaying).
     *
     * @param accessible true if accessible else false
     * @return the tooltip text.
     */
    protected String getPostfixForTooltip(boolean accessible) {
        StringBuffer postfix = new StringBuffer();
        // Determine if the tooltip must show the time difference between the current mouse position and
        // the last selected graphNode
        if ((fCurrentGraphNode != null) &&
                (fCurrentGraphNode instanceof ITimeRange) &&
                (fToolTipNode instanceof ITimeRange) &&
                (fCurrentGraphNode != fToolTipNode) &&
                ((ITimeRange) fToolTipNode).hasTimeInfo() &&
                ((ITimeRange) fCurrentGraphNode).hasTimeInfo()) {
            postfix.append(" -> "); //$NON-NLS-1$
            postfix.append(fCurrentGraphNode.getName());
            postfix.append("\n"); //$NON-NLS-1$
            postfix.append(Messages.SequenceDiagram_Delta);
            postfix.append(" "); //$NON-NLS-1$

            //double delta = ((ITimeRange)toolTipNode).getLastTime()-((ITimeRange)currentGraphNode).getLastTime();
            ITmfTimestamp firstTime = ((ITimeRange) fCurrentGraphNode).getEndTime();
            ITmfTimestamp lastTime = ((ITimeRange) fToolTipNode).getEndTime();
            ITmfTimestamp delta =  lastTime.getDelta(firstTime);
            postfix.append(delta.toString());

        } else {
            if ((fToolTipNode instanceof ITimeRange) && ((ITimeRange) fToolTipNode).hasTimeInfo()) {
                postfix.append("\n"); //$NON-NLS-1$
                ITmfTimestamp firstTime = ((ITimeRange) fToolTipNode).getStartTime();
                ITmfTimestamp lastTime = ((ITimeRange) fToolTipNode).getEndTime();

                if (firstTime != null) {
                    if (lastTime != null && firstTime.compareTo(lastTime) != 0) {
                        postfix.append("start: "); //$NON-NLS-1$
                        postfix.append(firstTime.toString());
                        postfix.append("\n"); //$NON-NLS-1$
                        postfix.append("end: "); //$NON-NLS-1$
                        postfix.append(lastTime.toString());
                        postfix.append("\n"); //$NON-NLS-1$
                        } else {
                            postfix.append(firstTime.toString());
                        }
                    }
                else if (lastTime != null) {
                    postfix.append(lastTime.toString());
                }
            }
        }
        return postfix.toString();
    }

    /**
     * Sets a new focused widget.
     *
     * @param newFocusShape A new focus shape.
     */
    protected void setFocus(int newFocusShape) {
        fFocusedWidget = newFocusShape;
        if (fFocusedWidget == -1) {
            getViewControl().getAccessible().setFocus(ACC.CHILDID_SELF);
        } else {
            getViewControl().getAccessible().setFocus(fFocusedWidget);
        }
    }

    /**
     * Highlight the given GraphNode<br>
     * The GraphNode is then displayed using the system default selection color
     *
     * @param node the GraphNode to highlight
     */
    protected void performSelection(GraphNode node) {
        if ((fCtrlSelection) || (fShiftSelection)) {
            if (node != null) {
                if (fSelectedNodeList.contains(node)) {
                    removeSelection(node);
                } else {
                    addSelection(node);
                }
            } else {
                return;
            }
        } else {
            clearSelection();
            if (node != null) {
                addSelection(node);
            }
        }
    }

    /**
     * Returns a draw buffer image.
     *
     * @return a Image containing the draw buffer.
     */
    protected Image getDrawBuffer() {

        update();
        Rectangle area = getClientArea();
        Image dbuffer = new Image(getDisplay(), area.width, area.height);
        GC gcim = new GC(dbuffer);
        NGC context = new NGC(this, gcim);

        // Set the metrics to use for lifeline text and message text
        // using the Graphical Context
        Metrics.setLifelineFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE)));
        Metrics.setLifelineFontWidth(context.getFontWidth(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE)));
        Metrics.setLifelineWidth(SDViewPref.getInstance().getLifelineWidth());
        Metrics.setFrameFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_FRAME_NAME)));
        Metrics.setLifelineHeaderFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE_HEADER)));

        int syncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_SYNC_MESS));
        int syncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_SYNC_MESS_RET));
        int asyncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_ASYNC_MESS));
        int asyncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_ASYNC_MESS_RET));

        int messageFontHeight = 0;
        if (syncMessFontH > syncMessRetFontH) {
            messageFontHeight = syncMessFontH;
        } else {
            messageFontHeight = syncMessRetFontH;
        }
        if (messageFontHeight < asyncMessFontH) {
            messageFontHeight = asyncMessFontH;
        }
        if (messageFontHeight < asyncMessRetFontH) {
            messageFontHeight = asyncMessRetFontH;
        }
        Metrics.setMessageFontHeight(messageFontHeight);
        context.setFont(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE));

        int width = (int) ((fFrame.getWidth() + 2 * Metrics.FRAME_H_MARGIN) * fZoomValue);
        int height = (int) ((fFrame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);

        resizeContents(width, height);

        context.setBackground(SDViewPref.getInstance().getBackGroundColor(ISDPreferences.PREF_FRAME));
        context.fillRectangle(0, 0, getContentsWidth(), Metrics.FRAME_V_MARGIN);
        context.fillRectangle(0, 0, fFrame.getX(), getContentsHeight());
        context.fillRectangle(fFrame.getX() + fFrame.getWidth() + 1, 0, getContentsWidth() - (fFrame.getX() + fFrame.getWidth() + 1), getContentsHeight());
        context.fillRectangle(0, fFrame.getY() + fFrame.getHeight() + 1, getContentsWidth(), getContentsHeight() - (fFrame.getY() + fFrame.getHeight() + 1));
        gcim.setLineWidth(1);

        fFrame.draw(context);
        if (fDragAndDrop != null) {
            Lifeline node = fDragAndDrop;
            boolean isSelected = fDragAndDrop.isSelected();
            boolean hasFocus = fDragAndDrop.hasFocus();
            node.setSelected(false);
            node.setFocused(false);
            node.draw(context, fDragX, fDragY);
            node.setSelected(isSelected);
            node.setFocused(hasFocus);
        }
        gcim.dispose();
        context.dispose();
        return dbuffer;
    }

    @Override
    protected void keyPressedEvent(KeyEvent event) {
        if (!(isFocusControl() || getViewControl().isFocusControl())) {
            Control[] child = getParent().getChildren();
            for (int i = 0; i < child.length; i++) {
                if ((child[i].isFocusControl())&& (!(child[i] instanceof ScrollView))) {
                    getViewControl().setFocus();
                    break;
                }
            }
        }
        setFocus(-1);

        if (event.keyCode == SWT.CTRL) {
            fCtrlSelection = true;
        }
        if (event.keyCode == SWT.SHIFT) {
            fShiftSelection = true;
            fPrevList = new ArrayList<>();
            fPrevList.addAll(getSelection());
        }

        GraphNode prevNode = getFocusNode();

        if (event.keyCode == SWT.ARROW_RIGHT) {
            traverseRight();
        }

        if (event.keyCode == SWT.ARROW_LEFT) {
            traverseLeft();
        }

        if (event.keyCode == SWT.ARROW_DOWN) {
            traverseDown();
        }

        if (event.keyCode == SWT.ARROW_UP) {
            traverseUp();
        }

        if (event.keyCode == SWT.HOME) {
            traverseHome();
        }

        if (event.keyCode == SWT.END) {
            traverseEnd();
        }

        if ((!fShiftSelection) && (!fCtrlSelection)) {
            fListStart = fCurrentGraphNode;
        }

        if (event.character == ' ') {
            performSelection(fCurrentGraphNode);
            if (!fShiftSelection) {
                fListStart = fCurrentGraphNode;
            }
        }

        if ((fShiftSelection) && (prevNode != getFocusNode())) {
            clearSelection();
            addSelection(fPrevList);
            addSelection(fFrame.getNodeList(fListStart, getFocusNode()));
            if (getFocusNode() instanceof Lifeline) {
                ensureVisible(getFocusNode().getX(), getFocusNode().getY(), getFocusNode().getWidth(), getFocusNode().getHeight(), SWT.CENTER | SWT.VERTICAL, true);
            } else {
                ensureVisible(getFocusNode());
            }
        } else if ((!fCtrlSelection) && (!fShiftSelection)) {

            clearSelection();
            if (getFocusNode() != null) {
                addSelection(getFocusNode());

                if (getFocusNode() instanceof Lifeline) {
                    ensureVisible(getFocusNode().getX(), getFocusNode().getY(), getFocusNode().getWidth(), getFocusNode().getHeight(), SWT.CENTER | SWT.VERTICAL, true);
                } else {
                    ensureVisible(getFocusNode());
                }
            }
        }

        if (fCurrentGraphNode != null) {
            fCurrentGraphNode.setFocused(true);
        }
        redraw();

        if ((event.character == ' ') && ((fZoomInMode) || (fZoomOutMode))) {
            int cx = Math.round((getContentsX() + getVisibleWidth() / 2) / fZoomValue);
            int cy = Math.round((getContentsY() + getVisibleHeight() / 2) / fZoomValue);
            if (fZoomInMode) {
                if (fZoomValue < 64) {
                    fZoomValue = fZoomValue * (float) 1.25;
                }
            } else {
                fZoomValue = fZoomValue / (float) 1.25;
            }
            int x = Math.round(cx * fZoomValue - getVisibleWidth() / (float) 2);
            int y = Math.round(cy * fZoomValue - getVisibleHeight() / (float) 2);
            setContentsPos(x, y);
            if (fTimeBar != null) {
                fTimeBar.setZoom(fZoomValue);
            }
            // redraw also resize the scrollView content
            redraw();
        }
    }

    @Override
    protected void keyReleasedEvent(KeyEvent event) {
        setFocus(-1);
        if (event.keyCode == SWT.CTRL) {
            fCtrlSelection = false;
        }
        if (event.keyCode == SWT.SHIFT) {
            fShiftSelection = false;
        }
        super.keyReleasedEvent(event);
        setFocus(1);
    }

    @Override
    public boolean isFocusControl() {
        Control[] child = getChildren();
        for (int i = 0; i < child.length; i++) {
            if (child[i].isFocusControl()) {
                return true;
            }
            checkFocusOnChilds(child[i]);
        }
        return false;
    }

    @Override
    public boolean setContentsPos(int x, int y) {
        int localX = x;
        int localY = y;

        if (localX < 0) {
            localX = 0;
        }
        if (localY < 0) {
            localY = 0;
        }
        if (fFrame == null) {
            return false;
        }
        if (localX + getVisibleWidth() > getContentsWidth()) {
            localX = getContentsWidth() - getVisibleWidth();
        }
        if (localY + getVisibleHeight() > getContentsHeight()) {
            localY = getContentsHeight() - getVisibleHeight();
        }
        int x1 = Math.round(localX / fZoomValue);
        int y2 = Math.round(localY / fZoomValue);
        int width = Math.round(getVisibleWidth() / fZoomValue);
        int height = Math.round(getVisibleHeight() / fZoomValue);
        fFrame.updateIndex(x1, y2, width, height);

        if (fInsertionCartet != null && fInsertionCartet.isVisible()) {
            fInsertionCartet.setVisible(false);
        }

        return super.setContentsPos(localX, localY);
    }

    @Override
    protected void contentsMouseHover(MouseEvent event) {
        GraphNode graphNode = null;
        if (fFrame != null) {
            int x = Math.round(event.x / fZoomValue);
            int y = Math.round(event.y / fZoomValue);
            graphNode = fFrame.getNodeAt(x, y);
            if ((graphNode != null) && (SDViewPref.getInstance().tooltipEnabled())) {
                fToolTipNode = graphNode;
                String postfix = getPostfixForTooltip(true);
                if (graphNode instanceof Lifeline) {
                    Lifeline lifeline = (Lifeline) graphNode;
                    fToolTip.showToolTip(lifeline.getToolTipText() + postfix);
                    setFocus(0);
                } else {
                    fToolTip.showToolTip(graphNode.getName() + postfix);
                    setFocus(0);
                }
            } else {
                fToolTip.hideToolTip();
            }
        }
    }

    @Override
    protected void contentsMouseMoveEvent(MouseEvent e) {
        fScrollToolTip.hideToolTip();
        fToolTip.hideToolTip();
        if (!(isFocusControl() || getViewControl().isFocusControl())) {
            Control[] child = getParent().getChildren();
            for (int i = 0; i < child.length; i++) {
                if ((child[i].isFocusControl()) && (!(child[i] instanceof ScrollView))) {
                    getViewControl().setFocus();
                    break;
                }
            }
        }
        setFocus(-1);

        if (((e.stateMask & SWT.BUTTON_MASK) != 0) && ((fDragAndDrop != null) || fIsDragAndDrop) && (fReorderMode || fCollapseProvider != null)) {
            fIsDragAndDrop = false;
            if (fCurrentGraphNode instanceof Lifeline) {
                fDragAndDrop = (Lifeline) fCurrentGraphNode;
            }
            if (fDragAndDrop != null) {
                int dx = 0;
                int dy = 0;
                if (e.x > getContentsX() + getVisibleWidth()) {
                    dx = e.x - (getContentsX() + getVisibleWidth());
                } else if (e.x < getContentsX()) {
                    dx = -getContentsX() + e.x;
                }
                if (e.y > getContentsY() + getVisibleHeight()) {
                    dy = e.y - (getContentsY() + getVisibleHeight());
                } else if (e.y < getContentsY()) {
                    dy = -getContentsY() + e.y;
                }
                fDragX = e.x;
                fDragY = e.y;
                if (dx != 0 || dy != 0) {
                    if (fLocalAutoScroll == null) {
                        if (fLocalAutoScrollTimer == null) {
                            fLocalAutoScrollTimer = new Timer(true);
                        }
                        fLocalAutoScroll = new AutoScroll(this, dx, dy);
                        fLocalAutoScrollTimer.schedule(fLocalAutoScroll, 0, 75);
                    } else {
                        fLocalAutoScroll.fDeltaX = dx;
                        fLocalAutoScroll.fDeltaY = dy;
                    }
                } else if (fLocalAutoScroll != null) {
                    fLocalAutoScroll.cancel();
                    fLocalAutoScroll = null;
                }
                fDragX = Math.round(e.x / fZoomValue);
                fDragY = Math.round(e.y / fZoomValue);
                redraw();
                Lifeline node = fFrame.getCloserLifeline(fDragX);
                if ((node != null) && (node != fDragAndDrop)) {
                    int y = 0;
                    int y1 = 0;
                    int height = Metrics.getLifelineHeaderFontHeigth() + 2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN;
                    int hMargin = Metrics.LIFELINE_VT_MAGIN / 4;
                    int x = node.getX();
                    int width = node.getWidth();
                    if (fFrame.getVisibleAreaY() < node.getY() + node.getHeight() - height - hMargin) {
                        y = contentsToViewY(Math.round((node.getY() + node.getHeight()) * fZoomValue));
                    } else {
                        y = Math.round(height * fZoomValue);
                    }

                    if (fFrame.getVisibleAreaY() < contentsToViewY(node.getY() - hMargin)) {
                        y1 = contentsToViewY(Math.round((node.getY() - hMargin) * fZoomValue));
                    } else {
                        y1 = Math.round(height * fZoomValue);
                    }

                    int rx = Math.round(x * fZoomValue);

                    fInsertionCartet.setVisible(true);
                    if ((fInsertionCartet.getImage() != null) && (!fInsertionCartet.getImage().isDisposed())) {
                        fInsertionCartet.getImage().dispose();
                    }
                    if (rx <= e.x && Math.round(rx + (width * fZoomValue)) >= e.x) {
                        if (fCollapseProvider != null) {
                            ImageData data = fCollapaseCaretImg.getImageData();
                            data = data.scaledTo(Math.round(fCollapaseCaretImg.getBounds().width * fZoomValue), Math.round(fCollapaseCaretImg.getBounds().height * fZoomValue));
                            fCurrentCaretImage = new Image(Display.getCurrent(), data);
                            fInsertionCartet.setImage(fCurrentCaretImage);
                            fInsertionCartet.setLocation(contentsToViewX(rx + Math.round((width / (float) 2) * fZoomValue)) - fCurrentCaretImage.getBounds().width / 2, y);
                        }
                    } else if (fReorderMode) {
                        if (rx > e.x) {
                            if (node.getIndex() > 1 && fFrame.getLifeline(node.getIndex() - 2) == fDragAndDrop) {
                                return;
                            }
                            ImageData data = fArrowUpCaretImg.getImageData();
                            data = data.scaledTo(Math.round(fArrowUpCaretImg.getBounds().width * fZoomValue), Math.round(fArrowUpCaretImg.getBounds().height * fZoomValue));
                            fCurrentCaretImage = new Image(Display.getCurrent(), data);
                            fInsertionCartet.setImage(fCurrentCaretImage);
                            fInsertionCartet.setLocation(contentsToViewX(Math.round((x - Metrics.LIFELINE_SPACING / 2) * fZoomValue)) - fCurrentCaretImage.getBounds().width / 2, y1);
                        } else {
                            if (node.getIndex() < fFrame.lifeLinesCount() && fFrame.getLifeline(node.getIndex()) == fDragAndDrop) {
                                return;
                            }
                            ImageData data = fArrowUpCaretImg.getImageData();
                            data = data.scaledTo(Math.round(fArrowUpCaretImg.getBounds().width * fZoomValue), Math.round(fArrowUpCaretImg.getBounds().height * fZoomValue));
                            fCurrentCaretImage = new Image(Display.getCurrent(), data);
                            fInsertionCartet.setImage(fCurrentCaretImage);
                            fInsertionCartet.setLocation(contentsToViewX(Math.round((x + width + Metrics.LIFELINE_SPACING / 2) * fZoomValue)) - fCurrentCaretImage.getBounds().width / 2 + 1, y1);
                        }
                    }
                } else {
                    fInsertionCartet.setVisible(false);
                }
            }
        } else {
            super.contentsMouseMoveEvent(e);
        }
    }

    @Override
    protected void contentsMouseUpEvent(MouseEvent event) {
        // Just in case the diagram highlight a time compression region
        // this region need to be released when clicking everywhere
        fInsertionCartet.setVisible(false);
        if (fDragAndDrop != null) {
            if ((fOverView != null) && (!fOverView.isDisposed())) {
                fOverView.dispose();
            }
            fOverView = null;
            Lifeline node = fFrame.getCloserLifeline(fDragX);
            if (node != null) {
                int rx = Math.round(node.getX() * fZoomValue);
                if (rx <= event.x && Math.round(rx + (node.getWidth() * fZoomValue)) >= event.x) {
                    if ((fCollapseProvider != null) && (fDragAndDrop != node)) {
                        fCollapseProvider.collapseTwoLifelines(fDragAndDrop, node);
                    }
                } else if (rx < event.x) {
                    fFrame.insertLifelineAfter(fDragAndDrop, node);
                    if (node.getIndex() < fFrame.lifeLinesCount()) {
                        Lifeline temp[] = { fDragAndDrop, fFrame.getLifeline(node.getIndex()) };
                        fReorderList.add(temp);
                    } else {
                        Lifeline temp[] = { fDragAndDrop, null };
                        fReorderList.add(temp);
                    }
                } else {
                    fFrame.insertLifelineBefore(fDragAndDrop, node);
                    Lifeline temp[] = { fDragAndDrop, node };
                    fReorderList.add(temp);
                }
            }
        }
        fDragAndDrop = null;
        redraw();
        if (fFrame == null) {
            return;
        }
        fFrame.resetTimeCompression();

        // reset auto scroll if it's engaged
        if (fLocalAutoScroll != null) {
            fLocalAutoScroll.cancel();
            fLocalAutoScroll = null;
        }
        super.contentsMouseUpEvent(event);
    }

    @Override
    protected void contentsMouseDownEvent(MouseEvent event) {
        if (fCurrentGraphNode != null) {
            fCurrentGraphNode.setFocused(false);
        }

        // Just in case the diagram highlight a time compression region
        // this region need to be released when clicking everywhere
        if (fFrame == null) {
            return;
        }

        fFrame.resetTimeCompression();

        if ((event.stateMask & SWT.CTRL) != 0) {
            fCtrlSelection = true;
        } else {
            fCtrlSelection = false;
        }

        if (((fZoomInMode) || (fZoomOutMode)) && (event.button == 1)) {
            int cx = Math.round(event.x / fZoomValue);
            int cy = Math.round(event.y / fZoomValue);
            if (fZoomInMode) {
                if (fZoomValue < 64) {
                    fZoomValue = fZoomValue * (float) 1.25;
                }
            } else {
                fZoomValue = fZoomValue / (float) 1.25;
            }
            int x = Math.round(cx * fZoomValue - getVisibleWidth() / (float) 2);
            int y = Math.round(cy * fZoomValue - getVisibleHeight() / (float) 2);
            setContentsPos(x, y);
            if (fTimeBar != null) {
                fTimeBar.setZoom(fZoomValue);
            }
            // redraw also resize the scrollView content
            redraw();
        } else {
            GraphNode node = null;
            int x = Math.round(event.x / fZoomValue);
            int y = Math.round(event.y / fZoomValue);
            node = fFrame.getNodeAt(x, y);

            if ((event.button == 1) || ((node != null) && !node.isSelected())) {
                if (!fShiftSelection) {
                    fListStart = node;
                }
                if (fShiftSelection) {
                    clearSelection();
                    addSelection(fFrame.getNodeList(fListStart, node));
                } else {
                    performSelection(node);
                }
                fCurrentGraphNode = node;
                if (node != null) {
                    node.setFocused(true);
                }
            }
            redraw();
        }
        if (fDragAndDrop == null) {
            super.contentsMouseDownEvent(event);
        }
        fIsDragAndDrop = (event.button == 1);

    }

    /**
     * TimerTask for auto scroll feature.
     */
    protected static class AutoScroll extends TimerTask {
        /**
         * Field delta x.
         */
        public int fDeltaX;
        /**
         * Field delta y.
         */
        public int fDeltaY;
        /**
         * Field sequence diagram reference.
         */
        public SDWidget fSdWidget;

        /**
         * Constructor for AutoScroll.
         * @param sv sequence diagram widget reference
         * @param dx delta x
         * @param dy delta y
         */
        public AutoScroll(SDWidget sv, int dx, int dy) {
            fSdWidget = sv;
            fDeltaX = dx;
            fDeltaY = dy;
        }

        @Override
        public void run() {
            Display display = Display.getDefault();
            if ((display == null) || (display.isDisposed())) {
                return;
            }
            display.asyncExec(new Runnable() {
                @Override
                public void run() {
                    if (fSdWidget.isDisposed()) {
                        return;
                    }
                    fSdWidget.fDragX += fDeltaX;
                    fSdWidget.fDragY += fDeltaY;
                    fSdWidget.scrollBy(fDeltaX, fDeltaY);
                }
            });
        }
    }

    @Override
    protected void drawContents(GC gc, int clipx, int clipy, int clipw, int cliph) {
        if (fFrame == null) {
            gc.setBackground(getDisplay().getSystemColor(SWT.COLOR_WHITE));
            gc.fillRectangle(0, 0, getVisibleWidth(), getVisibleHeight());
            gc.dispose();
            return;
        }
        SDViewPref.getInstance();

        Rectangle area = getClientArea();
        Image dbuffer = getDrawBuffer();
        int height = Math.round((fFrame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);

        try {
            gc.drawImage(dbuffer, 0, 0, area.width, area.height, 0, 0, area.width, area.height);
        } catch (Exception e) {
            Activator.getDefault().logError("Error drawin content", e); //$NON-NLS-1$
        }
        dbuffer.dispose();
        setHScrollBarIncrement(Math.round(SDViewPref.getInstance().getLifelineWidth() / (float) 2 * fZoomValue));
        setVScrollBarIncrement(Math.round(Metrics.getMessagesSpacing() * fZoomValue));
        if ((fTimeBar != null) && (fFrame.hasTimeInfo())) {
            fTimeBar.resizeContents(9, height + getHorizontalBarHeight());
            fTimeBar.setContentsPos(getContentsX(), getContentsY());
            fTimeBar.redraw();
            fTimeBar.update();
        }
        float xRatio = getContentsWidth() / (float) getVisibleWidth();
        float yRatio = getContentsHeight() / (float) getVisibleHeight();
        if (yRatio > xRatio) {
            setOverviewSize((int) (getVisibleHeight() * 0.75));
        } else {
            setOverviewSize((int) (getVisibleWidth() * 0.75));
        }
    }

    @Override
    public void widgetDefaultSelected(SelectionEvent event) {
    }

    @Override
    public void widgetSelected(SelectionEvent event) {
        if (event.widget == fZoomIn) {
            fZoomValue = fZoomValue * 2;
        } else if (event.widget == fZoomOut) {
            fZoomValue = fZoomValue / 2;
        }
        redraw();
    }

    /**
     * Called when property changed occurs in the preference page. "PREFOK" is
     * fired when the user press the ok or apply button
     */
    @Override
    public void propertyChange(PropertyChangeEvent e) {
        if (fFrame != null && !isDisposed()) {
            fFrame.resetTimeCompression();
        }
        if (e.getProperty().equals("PREFOK")) //$NON-NLS-1$
        {
            // Prepare the overview to be reused for the new
            // settings (especially the colors)
            if (fOverView != null) {
                fOverView.dispose();
            }
            fOverView = null;
            redraw();
        }
    }

    @Override
    public void widgetDisposed(DisposeEvent e) {
        if (fOverView != null) {
            fOverView.dispose();
        }
        super.removeDisposeListener(this);
        if ((fCurrentCaretImage != null) && (!fCurrentCaretImage.isDisposed())) {
            fCurrentCaretImage.dispose();
        }
        if ((fArrowUpCaretImg != null) && (!fArrowUpCaretImg.isDisposed())) {
            fArrowUpCaretImg.dispose();
        }
        if ((fCollapaseCaretImg != null) && (!fCollapaseCaretImg.isDisposed())) {
            fCollapaseCaretImg.dispose();
        }
        SDViewPref.getInstance().removePropertyChangeListener(this);
        LoadersManager lm = LoadersManager.getInstance();
        if (fSite instanceof SDView) {
            ((SDView) fSite).resetProviders();
            if (lm != null) {
                lm.resetLoader(((SDView) fSite).getViewSite().getId());
            }
        }
    }

    @Override
    protected void drawOverview(GC gc, Rectangle r) {
        float oldzoom = fZoomValue;
        if (getContentsWidth() > getContentsHeight()) {
            fZoomValue = (float) r.width / (float) getContentsWidth() * oldzoom;
        } else {
            fZoomValue = (float) r.height / (float) getContentsHeight() * oldzoom;
        }
        if ((fOverView != null) && ((r.width != fOverView.getBounds().width) || (r.height != fOverView.getBounds().height))) {
            fOverView.dispose();
            fOverView = null;
        }
        if (fOverView == null) {
            int backX = getContentsX();
            int backY = getContentsY();
            setContentsPos(0, 0);
            fOverView = new Image(getDisplay(), r.width, r.height);
            GC gcim = new GC(fOverView);
            NGC context = new NGC(this, gcim);
            context.setBackground(SDViewPref.getInstance().getBackGroundColor(ISDPreferences.PREF_FRAME));
            fFrame.draw(context);
            setContentsPos(backX, backY);
            gcim.dispose();
            context.dispose();
        }
        if ((fOverView != null) && (r.width == fOverView.getBounds().width) && (r.height == fOverView.getBounds().height)) {
            gc.drawImage(fOverView, 0, 0, r.width, r.height, 0, 0, r.width, r.height);
        }

        fZoomValue = oldzoom;

        super.drawOverview(gc, r);
    }

    @Override
    public void deltaSelected(Lifeline lifeline, int startEvent, int nbEvent, IColor color) {
        fFrame.highlightTimeCompression(lifeline, startEvent, nbEvent, color);
        ensureVisible(lifeline);
        int y1 = lifeline.getY() + lifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * startEvent;
        int y2 = lifeline.getY() + lifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * (startEvent + nbEvent);
        ensureVisible(lifeline.getX(), y1 - (Metrics.getLifelineHeaderFontHeigth() + +2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN), lifeline.getWidth(), y2 - y1 + 3, SWT.CENTER | SWT.VERTICAL, true);
        redraw();
        update();
    }

    @Override
    public int getVisibleWidth() {
        if (fIsPrinting) {
            return fPrinter.getClientArea().width;
        }
        return super.getVisibleWidth();
    }

    @Override
    public int getVisibleHeight() {
        if (fIsPrinting) {
            return fPrinter.getClientArea().height;
        }
        return super.getVisibleHeight();
    }

    @Override
    public int contentsToViewX(int x) {
        if (fIsPrinting) {
            int v = Math.round(fPrinterX * fPrinterZoom);
            return x - v;
        }
        return x - getContentsX();
    }

    @Override
    public int contentsToViewY(int y) {
        if (fIsPrinting) {
            int v = Math.round(fPrinterY * fPrinterZoom);
            return y - v;
        }
        return y - getContentsY();
    }

    @Override
    public int getContentsX() {
        if (fIsPrinting) {
            return Math.round(fPrinterX * fPrinterZoom);
        }
        return super.getContentsX();
    }

    @Override
    public int getContentsY() {
        if (fIsPrinting) {
            return Math.round(fPrinterY * fPrinterZoom);
        }
        return super.getContentsY();
    }

    /**
     * Traverse Listener implementation.
     */
    protected static class LocalTraverseListener implements TraverseListener {
        @Override
        public void keyTraversed(TraverseEvent e) {
            if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {
                e.doit = true;
            }
        }
    }

}