org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/uml2sd/core/Lifeline.java

   1 /**********************************************************************
   2  * Copyright (c) 2005, 2013 IBM Corporation, Ericsson
   3  * All rights reserved.   This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM - Initial API and implementation
  10  *     Bernd Hufmann - Updated for TMF
  11  **********************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.views.uml2sd.core;
  14
  15 import java.util.ArrayList;
  16 import java.util.List;
  17
  18 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IColor;
  19 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IGC;
  20 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IImage;
  21 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.preferences.ISDPreferences;
  22 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.preferences.SDViewPref;
  23
  24 /**
  25  * Lifeline is the UML2 lifeline graphical representation.<br>
  26  * Each lifeline owns a set of event occurrences. An event occurrence is the base element in UML2 to set an event in a
  27  * sequence diagram.<br>
  28  * Event occurrence define the drawing order of graph node along a lifeline. In this lifeline implementation, event
  29  * occurrences are just integer index. The event occurrences with the same value on different lifelines will correspond
  30  * the same y coordinate value.
  31  *
  32  * @version 1.0
  33  * @author sveyrier
  34  *
  35  */
  36 public class Lifeline extends GraphNode {
  37     // ------------------------------------------------------------------------
  38     // Constants
  39     // ------------------------------------------------------------------------
  40     /**
  41      * The life line tag.
  42      */
  43     public static final String LIFELINE_TAG = "Lifeline"; //$NON-NLS-1$
  44
  45     // ------------------------------------------------------------------------
  46     // Attribute
  47     // ------------------------------------------------------------------------
  48     /**
  49      * The lifeline position in the containing frame
  50      */
  51     protected int fIndexInFrame = 0;
  52     /**
  53      * The frame where the lifeline is drawn
  54      */
  55     protected Frame fFrame = null;
  56     /**
  57      * The current event occurrence created in the lifeline
  58      */
  59     protected int fEventOccurrence = 0;
  60     /**
  61      * The lifeline category.
  62      */
  63     protected int fCategory = -1;
  64     /**
  65      * Flag whether lifeline has time information available or not
  66      */
  67     protected boolean fHasTimeInfo = false;
  68
  69     // ------------------------------------------------------------------------
  70     // Constructors
  71     // ------------------------------------------------------------------------
  72     /**
  73      * Default constructor
  74      */
  75     public Lifeline() {
  76         fPrefId = ISDPreferences.PREF_LIFELINE;
  77     }
  78
  79     // ------------------------------------------------------------------------
  80     // Methods
  81     // ------------------------------------------------------------------------
  82     /*
  83      * (non-Javadoc)
  84      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getX()
  85      */
  86     @Override
  87     public int getX() {
  88         return Metrics.FRAME_H_MARGIN + Metrics.LIFELINE_H_MAGIN + (fIndexInFrame - 1) * Metrics.swimmingLaneWidth();
  89     }
  90
  91     /*
  92      * (non-Javadoc)
  93      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getY()
  94      */
  95     @Override
  96     public int getY() {
  97         return 2 * Metrics.FRAME_NAME_H_MARGIN + Metrics.LIFELINE_VT_MAGIN / 2 + Metrics.getFrameFontHeigth() + Metrics.getLifelineHeaderFontHeigth() + Metrics.FRAME_V_MARGIN + 2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN;
  98     }
  99
 100     /*
 101      * (non-Javadoc)
 102      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getWidth()
 103      */
 104     @Override
 105     public int getWidth() {
 106         return Metrics.getLifelineWidth();
 107     }
 108
 109     /*
 110      * (non-Javadoc)
 111      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getHeight()
 112      */
 113     @Override
 114     public int getHeight() {
 115         // Set room for two text lines
 116         return Metrics.getLifelineFontHeigth()/** 2 */
 117         + 2 * Metrics.LIFELINE_NAME_H_MARGIN;
 118     }
 119
 120     /**
 121      * Set the lifeline category for this lifeline.
 122      *
 123      * @param arrayIndex the index of the category to use
 124      * @see Frame#setLifelineCategories(LifelineCategories[])
 125      */
 126     public void setCategory(int arrayIndex) {
 127         fCategory = arrayIndex;
 128     }
 129
 130     /**
 131      * Returns the tooltip text for the lifeline. It is the combination between the category name(if any) and the
 132      * lifeline name
 133      *
 134      * @return the tooltip text
 135      */
 136     public String getToolTipText() {
 137         if (fCategory >= 0) {
 138             LifelineCategories[] categories = fFrame.getLifelineCategories();
 139             if (fCategory < categories.length) {
 140                 return categories[fCategory].getName() + " " + getName(); //$NON-NLS-1$
 141             }
 142         }
 143         return ""; //$NON-NLS-1$
 144     }
 145
 146     /**
 147      * Returns the index of the first visible Execution Occurrence in the execution occurrence array.<br>
 148      * Execution Occurrences are Y ordered in this array
 149      *
 150      * @return the first visible Execution Occurrence
 151      */
 152     public int getExecOccurrenceDrawIndex() {
 153         if (!fHasChilden) {
 154             return 0;
 155         }
 156         if (fIndexes.get(BasicExecutionOccurrence.EXEC_OCC_TAG) != null) {
 157             return fIndexes.get(BasicExecutionOccurrence.EXEC_OCC_TAG).intValue();
 158         }
 159         return 0;
 160     }
 161
 162     /**
 163      * Set the frame on which this lifeline must be drawn
 164      *
 165      * @param parentFrame
 166      *            Parent frame
 167      */
 168     protected void setFrame(Frame parentFrame) {
 169         fFrame = parentFrame;
 170         if (fHasTimeInfo) {
 171             fFrame.setHasTimeInfo(true);
 172         }
 173         if (fFrame.getMaxEventOccurrence() < getEventOccurrence() + 1) {
 174             fFrame.setMaxEventOccurrence(getEventOccurrence() + 1);
 175         }
 176     }
 177
 178     /**
 179      * Returns the frame which this lifeline is drawn
 180      *
 181      * @return the Frame
 182      */
 183     protected Frame getFrame() {
 184         return fFrame;
 185     }
 186
 187     /**
 188      * Set the lifeline position index in the containing frame
 189      *
 190      * @param index the lifeline X position
 191      */
 192     protected void setIndex(int index) {
 193         fIndexInFrame = index;
 194     }
 195
 196     /**
 197      * Returns the lifeline position in de the containing frame
 198      *
 199      * @return the X position
 200      */
 201     public int getIndex() {
 202         return fIndexInFrame;
 203     }
 204
 205     /**
 206      * Set the lifeline event occurrence to the value given in parameter This only change the current event occurrence,
 207      * greater event created on this lifeline are still valid and usable. This also need to inform the frame of the
 208      * operation mostly to store in the frame the greater event found in the diagram (used to determine the frame
 209      * height)
 210      *
 211      * @param eventOcc the new current event occurrence
 212      */
 213     public void setCurrentEventOccurrence(int eventOcc) {
 214         if ((fFrame != null) && (fFrame.getMaxEventOccurrence() < eventOcc)) {
 215             fFrame.setMaxEventOccurrence(eventOcc);
 216         }
 217         fEventOccurrence = eventOcc;
 218     }
 219
 220     /**
 221      * Returns the last created event occurrence along the lifeline.
 222      *
 223      * @return the current event occurrence
 224      */
 225     public int getEventOccurrence() {
 226         return fEventOccurrence;
 227     }
 228
 229     /**
 230      * Creates a new event occurrence along the lifeline.
 231      *
 232      * @return the new created event occurrence
 233      */
 234     public int getNewEventOccurrence() {
 235         setCurrentEventOccurrence(fEventOccurrence + 1);
 236         return fEventOccurrence;
 237     }
 238
 239     /**
 240      * Adds the execution occurrence given in parameter to the lifeline.<br>
 241      * A Execution occurrence is never drawn in the frame instead it is added to a lifeline
 242      *
 243      * @param exec the execution occurrence to add
 244      */
 245     public void addExecution(BasicExecutionOccurrence exec) {
 246         exec.setLifeline(this);
 247         addNode(exec);
 248         if ((fFrame != null) && (fFrame.getMaxEventOccurrence() < exec.fEndEventOccurrence)) {
 249             fFrame.setMaxEventOccurrence(exec.fEndEventOccurrence);
 250         }
 251     }
 252
 253     /**
 254      * Set whether lifeline has time information available or not.
 255      * @param value The value to set
 256      */
 257     protected void setTimeInfo(boolean value) {
 258         fHasTimeInfo = value;
 259         if ((fFrame != null) && value) {
 260             fFrame.setHasTimeInfo(value);
 261         }
 262     }
 263
 264     /**
 265      * Returns true if at least one execution occurrence has time info.
 266      *
 267      * @return true if at least one execution occurrence has time info
 268      */
 269     public boolean hasTimeInfo() {
 270         return fHasTimeInfo;
 271     }
 272
 273     /**
 274      * Returns the list of execution occurrence on this lifeline.
 275      *
 276      * @return the execution occurrence list
 277      */
 278     public List<GraphNode> getExecutions() {
 279         if (fHasChilden) {
 280             return fNodes.get(BasicExecutionOccurrence.EXEC_OCC_TAG);
 281         }
 282         return new ArrayList<GraphNode>();
 283     }
 284
 285     /*
 286      * (non-Javadoc)
 287      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#contains(int, int)
 288      */
 289     @Override
 290     public boolean contains(int xValue, int yValue) {
 291         int x = getX();
 292         int y = getY();
 293         int width = getWidth();
 294         int height = getHeight();
 295
 296         if (fFrame == null) {
 297             return false;
 298         }
 299         if (GraphNode.contains(x, y, width, height, xValue, yValue)) {
 300             return true;
 301         }
 302         if (GraphNode.contains(x + Metrics.getLifelineWidth() / 2 - Metrics.EXECUTION_OCCURRENCE_WIDTH / 2, y + height, Metrics.EXECUTION_OCCURRENCE_WIDTH, (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * fFrame.getMaxEventOccurrence()
 303                 + Metrics.LIFELINE_VB_MAGIN - 4, xValue, yValue)) {
 304             return true;
 305         }
 306
 307         height = Metrics.getLifelineFontHeigth() + 2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN;
 308         int hMargin = (Metrics.LIFELINE_VT_MAGIN - height) / 2;
 309
 310         if (hMargin >= 2) {
 311             if (fFrame.getVisibleAreaY() < y - height - hMargin) {
 312                 if (GraphNode.contains(x - Metrics.LIFELINE_SPACING / 2 + 1, y - height - hMargin, Metrics.swimmingLaneWidth() - 2, height + 1, xValue, yValue)) {
 313                     return true;
 314                 }
 315             } else {
 316                 if (GraphNode.contains(x - Metrics.LIFELINE_SPACING / 2 + 1, fFrame.getVisibleAreaY(), Metrics.swimmingLaneWidth() - 2, height, xValue, yValue)) {
 317                     return true;
 318                 }
 319             }
 320         }
 321         if (getNodeAt(xValue, yValue) != null) {
 322             return true;
 323         }
 324         return false;
 325     }
 326
 327     /**
 328      * Returns the lifeline visibility for the given visible area
 329      *
 330      * @param vx The x coordinate of the visible area
 331      * @param vy The y coordinate of the visible area
 332      * @param vwidth The width of the visible area
 333      * @param vheight The height of the visible area
 334      * @return true if visible false otherwise
 335      */
 336     @Override
 337     public boolean isVisible(int vx, int vy, int vwidth, int vheight) {
 338         int x = getX();
 339         int width = getWidth();
 340         if (((x >= vx) && (x <= vx + vwidth)) || ((x + width >= vx) && (x <= vx))) {
 341             return true;
 342         }
 343         return false;
 344     }
 345
 346     /**
 347      * Draws the name within the graphical context.
 348      *
 349      * @param context The graphical context.
 350      */
 351     protected void drawName(IGC context) {
 352         ISDPreferences pref = SDViewPref.getInstance();
 353
 354         int x = getX();
 355         int y = getY();
 356         int height = Metrics.getLifelineHeaderFontHeigth() + 2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN;
 357         int hMargin = Metrics.LIFELINE_VT_MAGIN / 4;// (Metrics.LIFELINE_NAME_H_MARGIN)/2;
 358
 359         context.setLineStyle(context.getLineSolidStyle());
 360         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_LIFELINE_HEADER));
 361         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_LIFELINE_HEADER));
 362         context.setFont(pref.getFont(ISDPreferences.PREF_LIFELINE_HEADER));
 363         if (hMargin >= 0) {
 364             if (fFrame.getVisibleAreaY() < y - height - hMargin) {
 365                 context.fillRectangle(x - Metrics.LIFELINE_SPACING / 2 + 1, y - height - hMargin, Metrics.swimmingLaneWidth() - 2, height);
 366                 context.drawRectangle(x - Metrics.LIFELINE_SPACING / 2 + 1, y - height - hMargin, Metrics.swimmingLaneWidth() - 2, height);
 367                 context.setForeground(pref.getFontColor(ISDPreferences.PREF_LIFELINE_HEADER));
 368                 context.drawTextTruncatedCentred(getName(), x + Metrics.LIFELINE_NAME_V_MARGIN - Metrics.LIFELINE_SPACING / 2 + 1, y - height - hMargin, Metrics.swimmingLaneWidth() - 2 * Metrics.LIFELINE_NAME_V_MARGIN - 2, height, true);
 369             } else {
 370                 context.fillRectangle(x - Metrics.LIFELINE_SPACING / 2 + 1, fFrame.getVisibleAreaY(), Metrics.swimmingLaneWidth() - 2, height);
 371                 context.drawRectangle(x - Metrics.LIFELINE_SPACING / 2 + 1, fFrame.getVisibleAreaY(), Metrics.swimmingLaneWidth() - 2, height);
 372                 context.setForeground(pref.getFontColor(ISDPreferences.PREF_LIFELINE_HEADER));
 373                 context.drawTextTruncatedCentred(getName(), x - Metrics.LIFELINE_SPACING / 2 + Metrics.LIFELINE_NAME_V_MARGIN + 1, fFrame.getVisibleAreaY(), Metrics.swimmingLaneWidth() - 2 * Metrics.LIFELINE_NAME_V_MARGIN - 2, height, true);
 374             }
 375         }
 376     }
 377
 378     /**
 379      * Force the lifeline to be drawn at the given coordinate
 380      *
 381      * @param context - the context to draw into
 382      * @param x - the x coordinate
 383      * @param y - the y coordinate
 384      */
 385     public void draw(IGC context, int x, int y) {
 386
 387         ISDPreferences pref = SDViewPref.getInstance();
 388
 389         // Set the draw color depending if the lifeline must be selected or not
 390         context.setLineWidth(Metrics.NORMAL_LINE_WIDTH);
 391         if (isSelected()) {
 392             if (pref.useGradienColor()) {
 393                 context.setGradientColor(pref.getBackGroundColor(ISDPreferences.PREF_LIFELINE));
 394             }
 395             context.setBackground(pref.getBackGroundColorSelection());
 396             context.setForeground(pref.getForeGroundColorSelection());
 397         } else {
 398             if (pref.useGradienColor()) {
 399                 context.setGradientColor(pref.getBackGroundColor(ISDPreferences.PREF_LIFELINE));
 400                 context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME));
 401             } else {
 402                 context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_LIFELINE));
 403             }
 404             context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_LIFELINE));
 405         }
 406         // Store the lifeline coordinates to save some calls
 407         int width = getWidth();
 408         int height = getHeight();
 409
 410         // Draw the rectangle which contain the lifeline name
 411         if (pref.useGradienColor()) {
 412             context.fillGradientRectangle(x, y, width, height / 2 - 7, true);
 413             context.fillRectangle(x, y + height / 2 - 8, width, +height / 2 - 5);
 414             context.fillGradientRectangle(x, y + height, width, -height / 2 + 6, true);
 415         } else {
 416             context.fillRectangle(x, y, width, height);
 417         }
 418         context.drawRectangle(x, y, width, height);
 419
 420         if (fCategory >= 0) {
 421             LifelineCategories[] categories = fFrame.getLifelineCategories();
 422             if (fCategory < categories.length) {
 423                 IImage image = categories[fCategory].getImage();
 424                 if (image != null) {
 425                     context.drawImage(image, x, y, width, height);
 426                 }
 427             }
 428         }
 429
 430         // Draw the lifeline label into the rectangle
 431         // The label is truncated if it cannot fit
 432         IColor temp = context.getForeground();
 433         context.setFont(pref.getFont(ISDPreferences.PREF_LIFELINE));
 434         context.setForeground(pref.getFontColor(ISDPreferences.PREF_LIFELINE));
 435         context.drawTextTruncatedCentred(getName(), x + Metrics.LIFELINE_NAME_V_MARGIN, y, Metrics.getLifelineWidth() - 2 * Metrics.LIFELINE_NAME_V_MARGIN, height, true);
 436
 437         context.setLineStyle(context.getLineDashStyle());
 438         context.setForeground(temp);
 439         int oldStyle = context.getLineStyle();
 440
 441         // Now draw the lifeline vertical line
 442         // this line height depends on a stop assignment
 443         // if there is no stop the line is drawn to the bottom of the frame
 444
 445         // by default set the height to reach the frame bottom
 446         int dashedLineEnd = y + height + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * fFrame.getMaxEventOccurrence() + Metrics.LIFELINE_VB_MAGIN;
 447         /*
 448          * if (stop != null) { dashedLineEnd = stop.getY(); }
 449          */
 450
 451         if (isSelected()) {
 452             context.setForeground(pref.getBackGroundColorSelection());
 453             context.setLineWidth(5);
 454             context.drawLine(x + Metrics.getLifelineWidth() / 2, y + height, x + Metrics.getLifelineWidth() / 2, dashedLineEnd - 4);
 455             context.setForeground(pref.getForeGroundColorSelection());
 456         }
 457
 458         context.setLineWidth(Metrics.NORMAL_LINE_WIDTH);
 459         context.drawLine(x + Metrics.getLifelineWidth() / 2, y + height, x + Metrics.getLifelineWidth() / 2, dashedLineEnd - 4);
 460         context.drawLine(x + Metrics.getLifelineWidth() / 2, y + height, x + Metrics.getLifelineWidth() / 2, dashedLineEnd - 4);
 461         context.setLineStyle(oldStyle);
 462
 463         context.setLineStyle(context.getLineSolidStyle());
 464
 465         if (hasFocus()) {
 466             drawFocus(context);
 467         }
 468
 469         super.drawChildenNodes(context);
 470     }
 471
 472     /**
 473      * Draws the select execution occurrence region using the given color
 474      *
 475      * @param context the graphical context
 476      * @param startEvent the region start
 477      * @param nbEvent the region height
 478      * @param color the color to use
 479      */
 480     public void highlightExecOccurrenceRegion(IGC context, int startEvent, int nbEvent, IColor color) {
 481         IColor backupColor = context.getBackground();
 482         context.setBackground(color);
 483         int x = getX() + Metrics.getLifelineWidth() / 2 - Metrics.EXECUTION_OCCURRENCE_WIDTH / 2;
 484         int y = getY() + getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * startEvent;
 485         int width = Metrics.EXECUTION_OCCURRENCE_WIDTH;
 486         int height = ((Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing())) * nbEvent;
 487         context.fillRectangle(x, y, width, height);
 488         context.setBackground(backupColor);
 489     }
 490
 491     /*
 492      * (non-Javadoc)
 493      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#draw(org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IGC)
 494      */
 495     @Override
 496     public void draw(IGC context) {
 497         draw(context, getX(), getY());
 498     }
 499
 500     /*
 501      * (non-Javadoc)
 502      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getArrayId()
 503      */
 504     @Override
 505     public String getArrayId() {
 506         return LIFELINE_TAG;
 507     }
 508
 509     /*
 510      * (non-Javadoc)
 511      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#positiveDistanceToPoint(int, int)
 512      */
 513     @Override
 514     public boolean positiveDistanceToPoint(int x, int y) {
 515         if (getX() > x - Metrics.swimmingLaneWidth()) {
 516             return true;
 517         }
 518         return false;
 519     }
 520
 521     /*
 522      * (non-Javadoc)
 523      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getNodeAt(int, int)
 524      */
 525     @Override
 526     public GraphNode getNodeAt(int x, int y) {
 527         int vy = 0;
 528         int vh = 0;
 529         if (getFrame() != null) {
 530             vy = getFrame().getVisibleAreaY();
 531             vh = getFrame().getVisibleAreaHeight();
 532         } else {
 533             return null;
 534         }
 535         if (getExecutions() == null) {
 536             return null;
 537         }
 538         for (int i = getExecOccurrenceDrawIndex(); i < getExecutions().size(); i++) {
 539             GraphNode node = getExecutions().get(i);
 540             if (node.getHeight() < 0) {
 541                 if (node.getY() + node.getHeight() > vy + vh) {
 542                     break;
 543                 }
 544             } else {
 545                 if (node.getY() > vy + vh) {
 546                     break;
 547                 }
 548             }
 549             if (node.contains(x, y)) {
 550                 GraphNode internal = node.getNodeAt(x, y);
 551                 if (internal != null) {
 552                     return internal;
 553                 }
 554                 return node;
 555             }
 556         }
 557         return null;
 558     }
 559 }