/**********************************************************************
 * 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 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM - Initial API and implementation
 *     Bernd Hufmann - Updated for TMF
 **********************************************************************/

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

import org.eclipse.tracecompass.tmf.ui.views.uml2sd.drawings.IColor;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.drawings.IGC;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.preferences.ISDPreferences;
import org.eclipse.tracecompass.tmf.ui.views.uml2sd.preferences.SDViewPref;

/**
 * The base UML2 syncMessages implementation.<br>
 * This abstract class only define one event occurrence to attach to the message.<br>
 * Usually a message has two event occurrences attached, one for both ends. But some syncMessages(like synchronous
 * syncMessages) only need one event occurrence to represent the time when they appear. Others kind of message
 * representations (like asynchronous syncMessages) will be responsible to define the missing second eventOccurrence
 * property.<br>
 * <br>
 *
 * @see Lifeline Lifeline for more event occurence details
 * @version 1.0
 * @author sveyrier
 */
public abstract class BaseMessage extends GraphNode {

    private static final int ARROW_LENGTH = 7;
    private static final double ARROW_ANGLE = 0.75;
    private static final Double ARROW_HEAD_Y = Double.valueOf(Math.sin(ARROW_ANGLE) * ARROW_LENGTH);
    private static final Double ARROW_HEAD_X = Double.valueOf(Math.cos(ARROW_ANGLE) * ARROW_LENGTH);
    // ------------------------------------------------------------------------
    // Attributes
    // ------------------------------------------------------------------------
    /**
     * The lifeline which send the message
     */
    private Lifeline fStartLifeline = null;
    /**
     * The lifeline which receive the message
     */
    private Lifeline fEndLifeline = null;
    /**
     * The visiblitiy flag.
     */
    private boolean fVisible = true;

    // ------------------------------------------------------------------------
    // Methods
    // ------------------------------------------------------------------------

    @Override
    public int getX() {
        // returns the exact x coordinate
        return getX(false);
    }

    @Override
    public int getY() {
        /*
         * Note: lifeline.getY() return the y coordinate of the top left corner of the rectangle which contain the
         * lifeline name getHeight return the height of this rectangle The message y coordinate is then relative to this
         * position depending of its eventOccurrence Space between syncMessages is constant
         */
        if ((fStartLifeline != null) && (fEndLifeline != null)) {
            /*
             * Regular message, both ends are attached to a lifeline
             */
            return fEndLifeline.getY() + fEndLifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * getEndOccurrence();

        }
        /*
         * UML2 lost message kind
         */
        if (fStartLifeline != null) {
            return fStartLifeline.getY() + fStartLifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * getEndOccurrence();
        }

        /*
         * UML2 found message kind
         */
        if (fEndLifeline != null) {
            return fEndLifeline.getY() + fEndLifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * getEndOccurrence();
        }
        // return 0 by default
        return 0;
    }

    @Override
    public int getWidth() {
        // Returns the exact width
        return getWidth(false);
    }

    @Override
    public int getHeight() {
        return 0;
    }

    /**
     * Returns the graph node x coordinate.<br>
     * Depending on the quick parameter a approximative or exact value is return.<br>
     * The approximative value does not take into account if both message ends are connected to a Lifeline Execution
     * Occurrence.<br>
     * Execution occurrence on a lifeline increase the vertical line width which represent the lifeline, this directly
     * affect the message x coordinate and width.<br>
     * <br>
     * This method is typically used to faster execute none graphical operation like tooltip lookup.<br>
     * <br>
     *
     * @param quick true to get an approximative value<br>
     *            false to get the exact x value<br>
     * @return the graph node x coordinate
     */
    protected int getX(boolean quick) {
        int x = 0;
        int activationWidth = Metrics.EXECUTION_OCCURRENCE_WIDTH / 2;
        if ((fStartLifeline != null) && (fEndLifeline != null)) {
            x = fStartLifeline.getX() + Metrics.getLifelineWidth() / 2;
        } else {
            if (fStartLifeline != null) {
                x = fStartLifeline.getX() + Metrics.getLifelineWidth() / 2;
            }

            if (fEndLifeline != null) {
                x = fEndLifeline.getX() - Metrics.LIFELINE_SPACING / 2;
            }
        }

        if (quick) {
            return x;
        }

        if ((fStartLifeline != null) && (fEndLifeline != null) && (fStartLifeline.getX() > fEndLifeline.getX())) {
            activationWidth = -activationWidth;
        }

        if (isMessageStartInActivation(getEndOccurrence())) {
            x = x + activationWidth;
        }

        return x;
    }

    /**
     * Returns the graph node width.<br>
     * Depending on the quick parameter a approximative or exact value is returned.<br>
     * The approximative value does not take into account if both message ends are connected to a Lifeline Execution
     * Occurrence.<br>
     * Execution occurrence on a lifeline increase the vertical line width which represent the lifeline, this directly
     * affect the message x coordinate and width.<br>
     * <br>
     * This method is typically used to faster execute none graphical operation like tooltip lookup.<br>
     * <br>
     *
     * @param quick true to get an approximative value<br>
     *            false to get the exact x value
     * @return the graph node width
     */
    protected int getWidth(boolean quick) {
        int width = 0;
        int activationWidth = Metrics.EXECUTION_OCCURRENCE_WIDTH / 2;
        if ((fStartLifeline != null) && (fEndLifeline != null)) {
            if (fStartLifeline.equals(fEndLifeline)) {
                width = Metrics.INTERNAL_MESSAGE_WIDTH + Metrics.EXECUTION_OCCURRENCE_WIDTH;
            } else {
                width = fEndLifeline.getX() + Metrics.getLifelineWidth() / 2 - getX(true);
            }
        } else {
            if (fStartLifeline != null) {
                width = Metrics.swimmingLaneWidth() / 2;
            }
            if (fEndLifeline != null) {
                width = Metrics.swimmingLaneWidth() / 2;
            }
        }

        if (quick) {
            return width;
        }

        if ((fStartLifeline != null) && (fEndLifeline != null) && (fStartLifeline.getX() > fEndLifeline.getX())) {
            activationWidth = -activationWidth;
        }

        if (isMessageStartInActivation(getEndOccurrence())) {
            width = width - activationWidth;
        }

        if (isMessageEndInActivation(getEndOccurrence())) {
            width = width - activationWidth;
        }

        return width;
    }

    @Override
    public boolean isVisible(int x, int y, int width, int height) {
        // ***Common*** syncMessages visibility
        // draw the message only if at least one end is visible
        if (fEndLifeline != null && (fEndLifeline.isVisible(x, y, width, height)) || (fStartLifeline != null && fStartLifeline.isVisible(x, y, width, height))) {
            return true;
        }
        // In this case it can be a message which cross the whole visible area
        else if (fEndLifeline != null && (!fEndLifeline.isVisible(x, y, width, height)) && (fStartLifeline != null && !fStartLifeline.isVisible(x, y, width, height))) {
            if (fEndLifeline.getX() > x + width && fStartLifeline.getX() < x) {
                return true;
            } else if (fStartLifeline.getX() > x + width && fEndLifeline.getX() < x) {
                return true;
            }
        }
        return false;
    }

    /**
     * Sets the visibility value.
     *
     * @param value The visibility to set.
     */
    public void setVisible(boolean value) {
        fVisible = value;
    }

    /**
     * @return the visibility value.
     */
    public boolean isVisible() {
        return fVisible;
    }

    /**
     * Set the lifeline from which this message has been sent.
     *
     * @param lifeline - the message sender
     */
    public void setStartLifeline(Lifeline lifeline) {
        fStartLifeline = lifeline;
    }

    /**
     * Returns the lifeline from which this message has been sent.
     *
     * @return the message sender
     */
    public Lifeline getStartLifeline() {
        return fStartLifeline;
    }

    /**
     * Returns the lifeline which has received this message.
     *
     * @return the message receiver
     */
    public Lifeline getEndLifeline() {
        return fEndLifeline;
    }

    /**
     * Set the lifeline which has receive this message.
     *
     * @param lifeline the message receiver
     */
    public void setEndLifeline(Lifeline lifeline) {
        fEndLifeline = lifeline;
    }

    /**
     * Set the event occurrence when this message occurs.<br>
     *
     * @param occurrence the event occurrence to assign to this message.<br>
     * @see Lifeline Lifeline for more event occurence details
     */
    protected void setEventOccurrence(int occurrence) {
        setEndOccurrence(occurrence);
    }

    /**
     * Returns the event occurence when is message occurs.<br>
     *
     * @return the event occurrence assigned to this message.<br>
     * @see Lifeline Lifeline for more event occurence details
     */
    public int getEventOccurrence() {
        return getEndOccurrence();
    }

    /**
     * Determines if the given eventOccurence occurs on a executionOccurence owned by the sending lifeline.<br>
     * WARNING: this method will return a valid result only for execution occurrences which are visible in the View.<br>
     * As consequence this method is only used for drawing purpose, especially to determine the exact message x
     * coordinate and width.<br>
     *
     * @see BaseMessage#getX(boolean)
     * @param event the event occurrence to test
     * @return true if occurs on a execution occurrence owned by the sending lifeine, false otherwise
     */
    protected boolean isMessageStartInActivation(int event) {
        boolean inActivation = false;
        if ((fStartLifeline != null) && (fStartLifeline.getExecutions() != null)) {
            // int acIndex=startLifeline.getExecOccurrenceDrawIndex();
            // acIndex = first visible execution occurrence
            // for drawing speed reason with only search on the visivle subset
            int thisY = getY();
            for (int i = 0; i < fStartLifeline.getExecutions().size(); i++) {
                BasicExecutionOccurrence toDraw = (BasicExecutionOccurrence) fStartLifeline.getExecutions().get(i);
                if ((event >= toDraw.getStartOccurrence()) && (event <= toDraw.getEndOccurrence())) {
                    inActivation = true;
                }
                // if we are outside the visible area we stop right now
                // This works because execution occurrences are ordered along the Y axis
                if (toDraw.getY() > thisY) {
                    break;
                }
            }
        }
        return inActivation;
    }

    /**
     * Determines if the given event occurrence occurs on a execution occurrence owned by the receiving lifeline.<br>
     * WARNING: this method will return a valid result only for execution occurrences which are visible in the View.<br>
     * As consequence this method is only used for drawing purpose, especially to determine the exact message x
     * coordinate and width.<br>
     *
     * @see BaseMessage#getX(boolean)
     * @param event the event occurrence to test
     * @return true if occurs on a execution occurrence owned by the receiving lifeline, false otherwise
     */
    protected boolean isMessageEndInActivation(int event) {
        boolean inActivation = false;
        if ((fEndLifeline != null) && (fEndLifeline.getExecutions() != null)) {
            // acIndex = first visible execution occurrence
            // for drawing speed reason with only search on the visivle subset
            for (int i = 0; i < fEndLifeline.getExecutions().size(); i++) {
                BasicExecutionOccurrence toDraw = (BasicExecutionOccurrence) fEndLifeline.getExecutions().get(i);
                if ((event >= toDraw.getStartOccurrence()) && (event <= toDraw.getEndOccurrence())) {
                    inActivation = true;
                }
                // if we are outside the visible area we stop right now
                // This works because execution occurrences are ordered along the Y axis
                if (toDraw.getY() > getY()) {
                    break;
                }
            }
        }
        return inActivation;
    }

    @Override
    public boolean contains(int xValue, int yValue) {
        int x = getX();
        int y = getY();
        int width = getWidth();
        int height = getHeight();

        // Used to create a rectangle which contains the message label to allow selection when clicking the label
        int tempHeight = Metrics.MESSAGES_NAME_SPACING + Metrics.getMessageFontHeigth();

        // Is it a self message?
        if (fStartLifeline.equals(fEndLifeline)) {
            /*
             * Rectangle.contains(x,y, width, height) does not works with negative height or width We check here if the
             * rectangle width is negative.
             */
            if (getName().length() * Metrics.getAverageCharWidth() > Metrics.swimmingLaneWidth() - Metrics.EXECUTION_OCCURRENCE_WIDTH / 2 + -Metrics.INTERNAL_MESSAGE_WIDTH) {
                if (GraphNode.contains(x + Metrics.INTERNAL_MESSAGE_WIDTH + 10, y, Metrics.swimmingLaneWidth() - Metrics.EXECUTION_OCCURRENCE_WIDTH / 2 + -Metrics.INTERNAL_MESSAGE_WIDTH, Metrics.getMessageFontHeigth(), xValue, yValue)) {
                    return true;
                }
            } else {
                if (GraphNode.contains(x + Metrics.INTERNAL_MESSAGE_WIDTH + 10, y, getName().length() * Metrics.getAverageCharWidth(), Metrics.getMessageFontHeigth(), xValue, yValue)) {
                    return true;
                }
            }

            // Test if the point is in part 1 of the self message
            // see: "private void drawMessage (NGC context)" method for self message drawing schema
            if (GraphNode.contains(x, y - Metrics.MESSAGE_SELECTION_TOLERANCE / 2, Metrics.INTERNAL_MESSAGE_WIDTH / 2, Metrics.MESSAGE_SELECTION_TOLERANCE, xValue, yValue)) {
                return true;
            }

            // Test if the point is in part 3 of the self message
            if (GraphNode.contains(x + Metrics.INTERNAL_MESSAGE_WIDTH - Metrics.MESSAGE_SELECTION_TOLERANCE / 2, y, Metrics.MESSAGE_SELECTION_TOLERANCE, height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT, xValue, yValue)) {
                return true;
            }

            // Test if the point is in part 5 of the self message
            return (GraphNode.contains(x, y + height - Metrics.MESSAGE_SELECTION_TOLERANCE / 2 + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT, Metrics.INTERNAL_MESSAGE_WIDTH / 2, Metrics.MESSAGE_SELECTION_TOLERANCE, xValue, yValue));
        }
        return GraphNode.contains(x, y - tempHeight, width, tempHeight, xValue, yValue);
    }

    /**
     * Method to draw the message using the graphical context.
     *
     * @param context A graphical context to draw in.
     */
    protected void drawMessage(IGC context) {
        int fX = 0;
        int fY = 0;
        int fW = 0;
        int fH = 0;

        // temporary store the coordinates to avoid more methods calls
        int x = getX();
        int y = getY();
        int width = getWidth();
        int height = getHeight();

        ISDPreferences pref = SDViewPref.getInstance();

        // UML2 found message (always drawn from left to right)
        // or UML2 lost message (always drawn from left to right)
        if ((fStartLifeline == null || fEndLifeline == null) && !fStartLifeline.equals(fEndLifeline)) {
            // Draw the message label above the message and centered
            // The label is truncated if it cannot fit between the two message end
            // 2*Metrics.MESSAGES_NAME_SPACING = space above the label + space below the label
            IColor temp = context.getForeground();
            context.setForeground(pref.getFontColor(getColorPrefId()));
            context.drawTextTruncatedCentred(getName(), x, y - Metrics.getMessageFontHeigth() - 2 * Metrics.MESSAGES_NAME_SPACING, width, 2 * Metrics.MESSAGES_NAME_SPACING + Metrics.getMessageFontHeigth(), !isSelected());
            context.setForeground(temp);
            int margin = 0;
            if (fEndLifeline == null) {
                margin = Metrics.MESSAGE_CIRCLE_RAY;
            }

            // Draw the message main line
            context.drawLine(x, y, x + width, y + height);
            // Draw the two little lines which make a arrow part of the message
            Double xt = ARROW_HEAD_X;
            Double yt = ARROW_HEAD_Y;
            if (context.getLineStyle() == context.getLineSolidStyle()) {
                IColor backcolor = context.getBackground();
                context.setBackground(context.getForeground());
                int[] points = { x + width - margin, y + height, x + width - xt.intValue() - margin, y + height - yt.intValue(), x + width - xt.intValue() - margin, y + height + yt.intValue(), x + width - margin, y + height };
                context.fillPolygon(points);
                context.drawPolygon(points);
                context.setBackground(backcolor);
            } else {
                int currentStyle = context.getLineStyle();
                int currentWidth = context.getLineWidth();
                context.setLineWidth(currentWidth + 2);
                context.setLineStyle(context.getLineSolidStyle());
                context.drawLine(x + width - xt.intValue() - margin, y + height - yt.intValue(), x + width - margin, y + height);
                context.drawLine(x + width - xt.intValue() - margin, y + height + yt.intValue(), x + width - margin, y + height);
                context.setLineStyle(currentStyle);
                context.setLineWidth(currentWidth);
            }
            IColor storedColor = context.getBackground();
            context.setBackground(context.getForeground());

            // Draw a circle at the message end (endLifeline side)
            int ray = Metrics.MESSAGE_CIRCLE_RAY;
            if (context.getLineWidth() != Metrics.NORMAL_LINE_WIDTH) {
                ray = ray + Metrics.SELECTION_LINE_WIDTH - Metrics.NORMAL_LINE_WIDTH;
            }
            if (fStartLifeline == null) {
                context.fillOval(x - ray, y - ray, ray * 2, ray * 2);
            } else {
                context.fillOval(x + width - ray, y + height - ray, ray * 2, ray * 2);
            }
            context.setBackground(storedColor);
            context.setForeground(pref.getFontColor(getColorPrefId()));
            fX = x;
            fY = y - yt.intValue();
            fW = width;
            fH = height + 2 * yt.intValue();
        }
        // it is self message (always drawn at the left side of the owning lifeLifeline)
        else if (fStartLifeline != null && fEndLifeline != null && fStartLifeline.equals(fEndLifeline)) {
            /*
             * Self syncMessages are drawn in 5 parts 1 -----------+ + 2 + | | | 3 | + 5 + 4 -----------+
             */
            int tempy = Metrics.INTERNAL_MESSAGE_WIDTH / 2;
            if (Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT <= Metrics.INTERNAL_MESSAGE_WIDTH) {
                tempy = Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT / 2;
            }

            // Part 1
            context.drawLine(x, y, x + Metrics.INTERNAL_MESSAGE_WIDTH / 2, y);
            // Part 3
            context.drawLine(x + Metrics.INTERNAL_MESSAGE_WIDTH, y + tempy, x + Metrics.INTERNAL_MESSAGE_WIDTH, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT - tempy);
            // Part 5
            context.drawLine(x, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT, x + Metrics.INTERNAL_MESSAGE_WIDTH / 2, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT);

            Double xt = ARROW_HEAD_X;
            Double yt = ARROW_HEAD_Y;

            fX = x;
            fY = y;
            fW = Metrics.INTERNAL_MESSAGE_WIDTH;
            fH = height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT;

            // Draw the two little lines which make a arrow part of the message
            if (context.getLineStyle() == context.getLineSolidStyle()) {
                IColor backcolor = context.getBackground();
                context.setBackground(context.getForeground());
                int[] points = { x, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT, x + xt.intValue(), y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT + yt.intValue(), x + xt.intValue(),
                        y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT - yt.intValue(), x, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT };
                context.fillPolygon(points);
                context.drawPolygon(points);
                context.setBackground(backcolor);
            } else {
                int currentStyle = context.getLineStyle();
                int currentWidth = context.getLineWidth();
                context.setLineWidth(currentWidth + 2);
                context.setLineStyle(context.getLineSolidStyle());
                context.drawLine(x + xt.intValue(), y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT + yt.intValue(), x, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT);
                context.drawLine(x + xt.intValue(), y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT - yt.intValue(), x, y + height + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT);
                context.setLineStyle(currentStyle);
                context.setLineWidth(currentWidth);
            }

            // Part 2
            context.drawArc(x, y, Metrics.INTERNAL_MESSAGE_WIDTH, 2 * tempy, 0, 90);
            // Part 4
            context.drawArc(x, y + Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT, Metrics.INTERNAL_MESSAGE_WIDTH, -2 * tempy, 0, -90);

            // Draw the message label above the message and centered
            // The label is truncated if it cannot fit between the two message end
            // 2*Metrics.MESSAGES_NAME_SPACING = space above the label + space below the label

            // the space available for the text is sorter if are drawing internal message on the last lifeline
            context.setForeground(pref.getFontColor(getColorPrefId()));
            if (fStartLifeline.getIndex() == fStartLifeline.getFrame().getHorizontalIndex()) {
                context.drawTextTruncated(getName(), x + width + Metrics.INTERNAL_MESSAGE_V_MARGIN / 2, y, Metrics.swimmingLaneWidth() / 2 - Metrics.EXECUTION_OCCURRENCE_WIDTH + -Metrics.INTERNAL_MESSAGE_WIDTH, +Metrics.MESSAGES_NAME_SPACING
                        - Metrics.getMessageFontHeigth(), !isSelected());
            } else {
                context.drawTextTruncated(getName(), x + width + Metrics.INTERNAL_MESSAGE_V_MARGIN / 2, y, Metrics.swimmingLaneWidth() - Metrics.EXECUTION_OCCURRENCE_WIDTH + -Metrics.INTERNAL_MESSAGE_WIDTH,
                        +Metrics.MESSAGES_NAME_SPACING - Metrics.getMessageFontHeigth(), !isSelected());
            }
        }
        // it is regular message
        else if (fStartLifeline != null && fEndLifeline != null) {
            // Draw the message main line
            context.drawLine(x, y, x + width, y + height);

            int spaceBTWStartEnd = fEndLifeline.getX() - fStartLifeline.getX();

            double a = height;
            double b = width;
            double angle = Math.atan(a / b);
            // Compute the coordinates of the two little lines which make the arrow part of the message
            int sign = 1;
            if (spaceBTWStartEnd < 0) {
                sign = -1;
            }
            Double x1 = Double.valueOf(sign * Math.cos(angle - ARROW_ANGLE) * ARROW_LENGTH);
            Double y1 = Double.valueOf(sign * Math.sin(angle - ARROW_ANGLE) * ARROW_LENGTH);
            Double x2 = Double.valueOf(sign * Math.cos(angle + ARROW_ANGLE) * ARROW_LENGTH);
            Double y2 = Double.valueOf(sign * Math.sin(angle + ARROW_ANGLE) * ARROW_LENGTH);

            fX = getX();
            fY = y + height - y2.intValue();
            fW = getWidth();
            fH = y2.intValue() - y1.intValue() + 1;
            if (fW < 0) {
                fW = -fW;
                fX = fX - fW;
            }

            if (fH < 0) {
                fH = -fH;
                fY = fY - fH;
            }

            // Draw the two little lines which make a arrow part of the message
            if (context.getLineStyle() == context.getLineSolidStyle()) {
                IColor backcolor = context.getBackground();
                context.setBackground(context.getForeground());
                int[] points = { x + width - x1.intValue(), y + height - y1.intValue(), x + width, y + height, x + width - x2.intValue(), y + height - y2.intValue(), x + width - x1.intValue(), y + height - y1.intValue() };
                context.fillPolygon(points);
                context.drawPolygon(points);
                context.setBackground(backcolor);
            } else {
                int currentStyle = context.getLineStyle();
                int currentWidth = context.getLineWidth();
                context.setLineWidth(currentWidth + 2);
                context.setLineStyle(context.getLineSolidStyle());
                context.drawLine(x + width - x1.intValue(), y + height - y1.intValue(), x + width, y + height);
                context.drawLine(x + width - x2.intValue(), y + height - y2.intValue(), x + width, y + height);
                context.setLineStyle(currentStyle);
                context.setLineWidth(currentWidth);
            }

            // Draw the message label above the message and centered
            // The label is truncated if it cannot fit between the two message end
            // 2*Metrics.MESSAGES_NAME_SPACING = space above the label + space below the label
            context.setForeground(pref.getFontColor(getColorPrefId()));
            if (spaceBTWStartEnd > 0) {
                context.drawTextTruncatedCentred(getName(), x, y + height / 2 - (2 * Metrics.MESSAGES_NAME_SPACING + Metrics.getMessageFontHeigth()), width, 2 * Metrics.MESSAGES_NAME_SPACING + Metrics.getMessageFontHeigth(), !isSelected());
            } else {
                context.drawTextTruncatedCentred(getName(), x + width, y + height / 2 - (2 * Metrics.MESSAGES_NAME_SPACING + Metrics.getMessageFontHeigth()), -width, 2 * Metrics.MESSAGES_NAME_SPACING + +Metrics.getMessageFontHeigth(), !isSelected());
            }
        }
    }

    @Override
    public void draw(IGC context) {
        if (!isVisible()) {
            return;
        }

        // Draw it selected?*/
        if (isSelected()) {
            ISDPreferences pref = SDViewPref.getInstance();
            /*
             * Draw it twice First time, bigger inverting selection colors Second time, regular drawing using selection
             * colors This create the highlight effect
             */
            context.setForeground(pref.getBackGroundColorSelection());
            context.setLineWidth(Metrics.SELECTION_LINE_WIDTH);
            drawMessage(context);
            context.setBackground(pref.getBackGroundColorSelection());
            context.setForeground(pref.getForeGroundColorSelection());
            // Second drawing is done after
        }
        context.setLineWidth(Metrics.NORMAL_LINE_WIDTH);
        if (hasFocus()) {
            context.setDrawTextWithFocusStyle(true);
        }
        drawMessage(context);
        int oldStyle = context.getLineStyle();
        if (hasFocus()) {
            context.setDrawTextWithFocusStyle(false);
            drawFocus(context);
        }
        // restore the context
        context.setLineStyle(oldStyle);
    }

    /**
     * Determine if two messages are identical. This default implementation considers that overlapping messages with
     * same coordinates are identical.
     *
     * @param message - the message to compare with
     * @return true if identical false otherwise
     *
     * @see org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.GraphNode#isSameAs(org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.GraphNode)
     */
    @Override
    public boolean isSameAs(GraphNode message) {
        if (message == null) {
            return false;
        }
        if (!(message instanceof BaseMessage)) {
            return super.isSameAs(message);
        }
        return ((getX() == message.getX()) && (getY() == message.getY()) && (getWidth() == message.getWidth()) && (getHeight() == message.getHeight()));
    }

    /**
     * Method drawRot.
     *
     * @param x A x coordinate
     * @param y A y coordinate
     * @param w A width
     * @param h A height
     * @param context A graphical context
     */
    public void drawRot(int x, int y, int w, int h, IGC context) {
        double angleA = Math.atan2(getHeight(), getWidth());
        double cosA = Math.cos(angleA);
        double sinA = Math.sin(angleA);

        int gx = getX();
        int gy = getY();

        int localHeight = h;
        localHeight = localHeight / 2;

        double cw = Math.sqrt(w * w + getHeight() * getHeight());

        int x1 = Math.round((float) ((x - gx) * cosA - (y - gy) * sinA));
        int y1 = Math.round((float) ((x - gx) * sinA + (y - gy) * cosA));

        int x2 = Math.round((float) (cw * cosA - (y - gy) * sinA));
        int y2 = Math.round((float) (cw * sinA + (y - gy) * cosA));

        int x3 = Math.round((float) (cw * cosA - (localHeight) * sinA));
        int y3 = Math.round((float) (cw * sinA + (localHeight) * cosA));

        int x4 = Math.round((float) ((x - gx) * cosA - (localHeight) * sinA));
        int y4 = Math.round((float) ((x - gx) * sinA + (localHeight) * cosA));

        int[] points = { x1 + getX(), y1 + getY(), x2 + getX(), y2 + getY(), x3 + getX(), y3 + getY(), x4 + getX(), y4 + getY() };
        context.drawPolygon(points);
    }

    @Override
    public void drawFocus(IGC context) {

        ISDPreferences pref = SDViewPref.getInstance();

        if ((!fStartLifeline.equals(fEndLifeline)) && (getStartOccurrence() == getEndOccurrence())) {
            context.setLineStyle(context.getLineDotStyle());
            context.setLineWidth(Metrics.NORMAL_LINE_WIDTH);
            context.setBackground(pref.getBackGroundColorSelection());
            context.setForeground(pref.getForeGroundColorSelection());
            context.drawFocus(getX(), getY() - 3, getWidth(), getHeight() + 6);
        } else if ((fStartLifeline == fEndLifeline) && (getStartOccurrence() == getEndOccurrence())) {
            context.drawFocus(getX(), getY() - 3, getWidth(), Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT + 6);
        } else if ((!fStartLifeline.equals(fEndLifeline)) && (getStartOccurrence() != getEndOccurrence())) {
            context.setLineStyle(context.getLineDotStyle());
            context.setLineWidth(Metrics.NORMAL_LINE_WIDTH);
            context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_LIFELINE_HEADER));
            context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_LIFELINE_HEADER));
            drawRot(getX(), getY() - 5, getWidth(), 10, context);
        } else {
            super.drawFocus(context);
        }
    }
}