org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/uml2sd/core/BasicFrame.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.Iterator;
  17 import java.util.List;
  18
  19 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
  20 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
  21 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IGC;
  22 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.preferences.ISDPreferences;
  23 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.preferences.SDViewPref;
  24
  25 /**
  26  * The Frame class is the base sequence diagram graph nodes container.<br>
  27  * For instance, only one frame can be drawn in the View.<br>
  28  * Lifelines, Messages and Stop which are supposed to represent a Sequence diagram are drawn in a Frame.<br>
  29  * Only the graph node added to their representing list will be drawn.
  30  *
  31  * The lifelines are appended along the X axsis when added in a frame.<br>
  32  * The syncMessages are ordered along the Y axsis depending on the event occurrence they are attached to.<br>
  33  *
  34  * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Lifeline Lifeline for more event occurence details
  35  * @author sveyrier
  36  * @version 1.0
  37  */
  38 public class BasicFrame extends GraphNode {
  39
  40     // ------------------------------------------------------------------------
  41     // Attributes
  42     // ------------------------------------------------------------------------
  43
  44     /**
  45      * Contains the max elapsed time between two consecutive messages in the whole frame
  46      */
  47     private ITmfTimestamp fMaxTime = new TmfTimestamp(0);
  48     /**
  49      * Contains the min elapsed time between two consecutive messages in the whole frame
  50      */
  51     private ITmfTimestamp fMinTime = new TmfTimestamp(0);
  52     /**
  53      * Indicate if the min and max elapsed time between two consecutive messages in the whole frame need to be computed
  54      */
  55     private boolean fComputeMinMax = true;
  56     /**
  57      * Store the preference set by the user regarding the external time. This flag is used determine if the min and max
  58      * need to be recomputed in case this preference is changed.
  59      */
  60     private boolean fLastExternalTimePref = SDViewPref.getInstance().excludeExternalTime();
  61     /**
  62      * The greater event occurrence created on graph nodes drawn in this Frame This directly impact the Frame height
  63      */
  64     private int fVerticalIndex = 0;
  65     /**
  66      * The index along the x axis where the next lifeline will is drawn This directly impact the Frame width
  67      */
  68     private int fHorizontalIndex = 0;
  69     /**
  70      * The time information flag.
  71      */
  72     private boolean fHasTimeInfo = false;
  73     /**
  74      * The current Frame visible area - x coordinates
  75      */
  76     private int fVisibleAreaX;
  77     /**
  78      * The current Frame visible area - y coordinates
  79      */
  80     private int fVisibleAreaY;
  81     /**
  82      * The current Frame visible area - width
  83      */
  84     private int fVisibleAreaWidth;
  85     /**
  86      * The current Frame visible area - height
  87      */
  88     private int fVisibleAreaHeight;
  89     /**
  90      * The event occurrence spacing (-1 for none)
  91      */
  92     private int fForceEventOccurrenceSpacing = -1;
  93     /**
  94      * Flag to indicate customized minumum and maximum.
  95      */
  96     private boolean fCustomMinMax = false;
  97     /**
  98      * The minimum time between messages of the sequence diagram frame.
  99      */
 100     private ITmfTimestamp fMinSDTime = new TmfTimestamp();
 101     /**
 102      * The maximum time between messages of the sequence diagram frame.
 103      */
 104     private ITmfTimestamp fMaxSDTime = new TmfTimestamp();
 105     /**
 106      * Flag to indicate that initial minimum has to be computed.
 107      */
 108     private boolean fInitSDMin = true;
 109
 110     // ------------------------------------------------------------------------
 111     // Constructors
 112     // ------------------------------------------------------------------------
 113
 114     /**
 115      * Creates an empty frame.
 116      */
 117     public BasicFrame() {
 118         Metrics.setForcedEventSpacing(fForceEventOccurrenceSpacing);
 119     }
 120
 121     // ------------------------------------------------------------------------
 122     // Methods
 123     // ------------------------------------------------------------------------
 124
 125     /**
 126      *
 127      * Returns the greater event occurence known by the Frame
 128      *
 129      * @return the greater event occurrence
 130      */
 131     protected int getMaxEventOccurrence() {
 132         return fVerticalIndex;
 133     }
 134
 135     /**
 136      * Set the greater event occurrence created in GraphNodes included in the frame
 137      *
 138      * @param eventOccurrence the new greater event occurrence
 139      */
 140     protected void setMaxEventOccurrence(int eventOccurrence) {
 141         fVerticalIndex = eventOccurrence;
 142     }
 143
 144     /**
 145      * This method increase the lifeline place holder The return value is usually assign to a lifeline. This can be used
 146      * to set the lifelines drawing order. Also, calling this method two times and assigning only the last given index
 147      * to a lifeline will increase this lifeline draw spacing (2 times the default spacing) from the last added
 148      * lifeline.
 149      *
 150      * @return a new lifeline index
 151      */
 152     protected int getNewHorizontalIndex() {
 153         return ++fHorizontalIndex;
 154     }
 155
 156     /**
 157      * Returns the current horizontal index
 158      *
 159      * @return the current horizontal index
 160      * @see Frame#getNewHorizontalIndex() for horizontal index description
 161      */
 162     protected int getHorizontalIndex() {
 163         return fHorizontalIndex;
 164     }
 165
 166     @Override
 167     public void addNode(GraphNode nodeToAdd) {
 168         setComputeMinMax(true);
 169         super.addNode(nodeToAdd);
 170     }
 171
 172     @Override
 173     public int getX() {
 174         return Metrics.FRAME_H_MARGIN;
 175     }
 176
 177     @Override
 178     public int getY() {
 179         return Metrics.FRAME_V_MARGIN;
 180     }
 181
 182     @Override
 183     public int getWidth() {
 184         if (fHorizontalIndex == 0) {
 185             return 3 * Metrics.swimmingLaneWidth() + Metrics.LIFELINE_H_MAGIN * 2 - Metrics.FRAME_H_MARGIN - Metrics.LIFELINE_SPACING / 2;
 186         }
 187         return fHorizontalIndex * Metrics.swimmingLaneWidth() + Metrics.LIFELINE_H_MAGIN * 2 + 1 - Metrics.LIFELINE_SPACING;
 188     }
 189
 190     @Override
 191     public int getHeight() {
 192         // The Frame height depends on the maximum number of messages added to a lifeline
 193         if (fVerticalIndex == 0) {
 194             return 5 * (Metrics.getMessagesSpacing() + Metrics.getMessageFontHeigth()) + Metrics.LIFELINE_NAME_H_MARGIN + Metrics.FRAME_NAME_H_MARGIN + Metrics.getFrameFontHeigth() + Metrics.LIFELINE_VT_MAGIN + Metrics.LIFELINE_VB_MAGIN
 195                     + Metrics.LIFELINE_NAME_H_MARGIN + Metrics.FRAME_NAME_H_MARGIN + Metrics.getLifelineFontHeigth() * 2;
 196         }
 197         if (fForceEventOccurrenceSpacing >= 0) {
 198             Metrics.setForcedEventSpacing(fForceEventOccurrenceSpacing);
 199         }
 200         return fVerticalIndex * (Metrics.getMessagesSpacing() + Metrics.getMessageFontHeigth()) + Metrics.LIFELINE_NAME_H_MARGIN + Metrics.FRAME_NAME_H_MARGIN + Metrics.getFrameFontHeigth() + Metrics.LIFELINE_VT_MAGIN + Metrics.LIFELINE_VB_MAGIN
 201                 + Metrics.LIFELINE_NAME_H_MARGIN + Metrics.FRAME_NAME_H_MARGIN + Metrics.getLifelineFontHeigth() * 2;
 202     }
 203
 204     /**
 205      * @return true if mininum and maximum time needs to be calculated else false
 206      * @since 2.0
 207      */
 208     protected boolean isComputeMinMax() {
 209         return fComputeMinMax;
 210     }
 211
 212     /**
 213      * @return true if mininum and maximum time needs to be calculated else false
 214      * @since 2.0
 215      */
 216     protected boolean isCustomMinMax() {
 217         return fCustomMinMax;
 218     }
 219
 220     /**
 221      * gets the initialization flag for SD minimum.
 222      *
 223      * @return the initialization flag for SD minimum
 224      * @since 2.0
 225      */
 226     protected boolean getInitSDMin() {
 227         return fInitSDMin;
 228     }
 229
 230     /**
 231      * Returns the graph node which contains the point given in parameter for the given graph node list and starting the
 232      * iteration at the given index<br>
 233      * WARNING: Only graph nodes with smaller coordinates than the current visible area can be returned.<br>
 234      *
 235      * @param x the x coordinate of the point to test
 236      * @param y the y coordinate of the point to test
 237      * @param list the list to search in
 238      * @param fromIndex list browsing starting point
 239      * @return the graph node containing the point given in parameter, null otherwise
 240      *
 241      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getNodeFromListAt(int, int, java.util.List, int)
 242      */
 243     @Override
 244     protected GraphNode getNodeFromListAt(int x, int y, List<GraphNode> list, int fromIndex) {
 245         if (list == null) {
 246             return null;
 247         }
 248         for (int i = fromIndex; i < list.size(); i++) {
 249             GraphNode node = list.get(i);
 250             // only lifeline list is x ordered
 251             // Stop browsing the list if the node is outside the visible area
 252             // all others nodes will be not visible
 253             if ((node instanceof Lifeline) && (node.getX() > fVisibleAreaX + fVisibleAreaWidth)) {
 254                 break;
 255             }
 256             if (node.getHeight() < 0) {
 257                 if (node.getY() + node.getHeight() > fVisibleAreaY + fVisibleAreaHeight) {
 258                     break;
 259                 }
 260             } else {
 261                 if (node.getY() > fVisibleAreaY + fVisibleAreaHeight) {
 262                     break;
 263                 }
 264             }
 265             if (node.contains(x, y)) {
 266                 return node;
 267             }
 268         }
 269         return null;
 270     }
 271
 272     /**
 273      * Draw the Frame rectangle
 274      *
 275      * @param context the context to draw to
 276      */
 277     protected void drawFrame(IGC context) {
 278
 279         ISDPreferences pref = SDViewPref.getInstance();
 280
 281         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME));
 282         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_FRAME));
 283
 284         int x = getX();
 285         int y = getY();
 286         int w = getWidth();
 287         int h = getHeight();
 288
 289         // Draw the frame main rectangle
 290         context.fillRectangle(x, y, w, h);
 291         context.drawRectangle(x, y, w, h);
 292
 293         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME_NAME));
 294         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_FRAME_NAME));
 295         context.setFont(pref.getFont(ISDPreferences.PREF_FRAME_NAME));
 296
 297         int nameWidth = context.textExtent(getName()) + 2 * Metrics.FRAME_NAME_V_MARGIN;
 298         int nameHeight = Metrics.getFrameFontHeigth() + +Metrics.FRAME_NAME_H_MARGIN * 2;
 299
 300         // Draw the frame name area
 301         if (nameWidth > w) {
 302             nameWidth = w;
 303         }
 304
 305         int[] points = { x, y, x + nameWidth, y, x + nameWidth, y - 11 + nameHeight, x - 11 + nameWidth, y + nameHeight, x, y + nameHeight, x, y + nameHeight };
 306         context.fillPolygon(points);
 307         context.drawPolygon(points);
 308         context.drawLine(x, y, x, y + nameHeight);
 309
 310         context.setForeground(pref.getFontColor(ISDPreferences.PREF_FRAME_NAME));
 311         context.drawTextTruncatedCentred(getName(), x, y, nameWidth - 11, nameHeight, false);
 312
 313         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME));
 314         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_FRAME));
 315     }
 316
 317     @Override
 318     public void draw(IGC context) {
 319         draw(context, true);
 320     }
 321
 322     /**
 323      * Draws the Frame on the given context.<br>
 324      * This method start width GraphNodes ordering if needed.<br>
 325      * After, depending on the visible area, only visible GraphNodes are drawn.<br>
 326      *
 327      * @param context the context to draw to
 328      * @param drawFrame indicate if the frame rectangle need to be redrawn
 329      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#draw(IGC)
 330      */
 331     protected void draw(IGC context, boolean drawFrame) {
 332         fVisibleAreaHeight = context.getVisibleHeight();
 333         fVisibleAreaWidth = context.getVisibleWidth();
 334         fVisibleAreaX = context.getContentsX();
 335         fVisibleAreaY = context.getContentsY();
 336
 337         if (fForceEventOccurrenceSpacing >= 0) {
 338             Metrics.setForcedEventSpacing(fForceEventOccurrenceSpacing);
 339         } else {
 340             Metrics.setForcedEventSpacing(-1);
 341         }
 342
 343         super.drawChildenNodes(context);
 344     }
 345
 346     /**
 347      * Sets the event occurrence spacing (-1 for none)
 348      *
 349      * @param space A spacing to set.
 350      */
 351     public void forceEventOccurrenceSpacing(int space) {
 352         fForceEventOccurrenceSpacing = space;
 353     }
 354
 355     /**
 356      * Return the X coordinates of the frame visible area
 357      *
 358      * @return the X coordinates of the frame visible area
 359      */
 360     public int getVisibleAreaX() {
 361         return fVisibleAreaX;
 362     }
 363
 364     /**
 365      * Return the frame visible area width
 366      *
 367      * @return the frame visible area width
 368      */
 369     public int getVisibleAreaWidth() {
 370         return fVisibleAreaWidth;
 371     }
 372
 373     /**
 374      * Return the frame visible area height
 375      *
 376      * @return the frame visible area height
 377      */
 378     public int getVisibleAreaHeight() {
 379         return fVisibleAreaHeight;
 380     }
 381
 382     /**
 383      * Return the X coordinates of the frame visible area
 384      *
 385      * @return the X coordinates of the frame visible area
 386      */
 387     public int getVisibleAreaY() {
 388         return fVisibleAreaY;
 389     }
 390
 391     /**
 392      * Return the minimum time stored in the frame taking all GraphNodes into account
 393      *
 394      * @return the minimum GraphNode time
 395      * @since 2.0
 396      */
 397     public ITmfTimestamp getMinTime() {
 398         if (fLastExternalTimePref != SDViewPref.getInstance().excludeExternalTime()) {
 399             fLastExternalTimePref = SDViewPref.getInstance().excludeExternalTime();
 400             setComputeMinMax(true);
 401         }
 402         if ((fComputeMinMax) && (!fCustomMinMax)) {
 403             computeMinMax();
 404             setComputeMinMax(false);
 405         }
 406         return fMinTime;
 407     }
 408
 409     /**
 410      * Set the minimum timestamp of the frame.
 411      *
 412      * @param min
 413      *            The minimum timestamp
 414      * @since 2.0
 415      */
 416     public void setMin(ITmfTimestamp min) {
 417         fMinTime = min;
 418         fCustomMinMax = true;
 419     }
 420
 421     /**
 422      * Set the maximum timestamp of the frame.
 423      *
 424      * @param max
 425      *            The maximum timestamp
 426      * @since 2.0
 427      */
 428     public void setMax(ITmfTimestamp max) {
 429         fMaxTime = max;
 430         fCustomMinMax = true;
 431     }
 432
 433     /**
 434      * Reset min/max timestamp values to the default ones.
 435      */
 436     public void resetCustomMinMax() {
 437         fCustomMinMax = false;
 438         setComputeMinMax(true);
 439     }
 440
 441     /**
 442      * Return the maximum time stored in the frame taking all GraphNodes into account
 443      *
 444      * @return the maximum GraphNode time
 445      * @since 2.0
 446      */
 447     public ITmfTimestamp getMaxTime() {
 448         if (fLastExternalTimePref != SDViewPref.getInstance().excludeExternalTime()) {
 449             fLastExternalTimePref = SDViewPref.getInstance().excludeExternalTime();
 450             setComputeMinMax(true);
 451         }
 452         if (fComputeMinMax) {
 453             computeMinMax();
 454             setComputeMinMax(false);
 455         }
 456         return fMaxTime;
 457     }
 458
 459     /**
 460      * Computes the minimum and maximum time between consecutive messages within the frame.
 461      */
 462     protected void computeMaxMinTime() {
 463         if (!fInitSDMin) {
 464             return;
 465         }
 466
 467         List<SDTimeEvent> timeArray = buildTimeArray();
 468
 469         if ((timeArray == null) || timeArray.isEmpty()) {
 470             return;
 471         }
 472         for (int i = 0; i < timeArray.size(); i++) {
 473             SDTimeEvent m = timeArray.get(i);
 474
 475             if (m.getTime().compareTo(fMaxSDTime, true) > 0) {
 476                 fMaxSDTime = m.getTime();
 477             }
 478
 479             if ((m.getTime().compareTo(fMinSDTime, true) < 0) || fInitSDMin) {
 480                 fMinSDTime = m.getTime();
 481                 fInitSDMin = false;
 482             }
 483         }
 484     }
 485
 486     /**
 487      * Returns the minimum time between consecutive messages.
 488      *
 489      * @return the minimum time between consecutive messages
 490      * @since 2.0
 491      */
 492     public ITmfTimestamp getSDMinTime() {
 493         computeMaxMinTime();
 494         return fMinSDTime;
 495     }
 496
 497     /**
 498      * Returns the maximum time between consecutive messages.
 499      *
 500      * @return the maximum time between consecutive messages
 501      * @since 2.0
 502      */
 503     public ITmfTimestamp getSDMaxTime() {
 504         computeMaxMinTime();
 505         return fMaxSDTime;
 506     }
 507
 508     /**
 509      * Browse all the GraphNode to compute the min and max times store in the Frame
 510      */
 511     protected void computeMinMax() {
 512         List<SDTimeEvent> timeArray = buildTimeArray();
 513
 514         if ((timeArray == null) || timeArray.isEmpty()) {
 515             return;
 516         }
 517         for (int i = 0; i < timeArray.size() - 1; i++) {
 518             SDTimeEvent m1 = timeArray.get(i);
 519             SDTimeEvent m2 = timeArray.get(i + 1);
 520
 521             updateMinMax(m1, m2);
 522         }
 523     }
 524
 525     /**
 526      * Updates the minimum and maximum time between consecutive message within the frame based on the given values.
 527      *
 528      * @param m1 A first SD time event.
 529      * @param m2 A second SD time event.
 530      */
 531     protected void updateMinMax(SDTimeEvent m1, SDTimeEvent m2) {
 532         ITmfTimestamp delta = m2.getTime().getDelta(m1.getTime());
 533         if (fComputeMinMax) {
 534             fMinTime = delta;
 535             if (fMinTime.compareTo(TmfTimestamp.ZERO, false) < 0) {
 536                 fMinTime = new TmfTimestamp(0, m1.getTime().getScale(), m1.getTime().getPrecision());
 537             }
 538             fMaxTime = fMinTime;
 539             setComputeMinMax(false);
 540         }
 541
 542         if ((delta.compareTo(fMinTime, true) < 0) && (delta.compareTo(TmfTimestamp.ZERO, false) > 0)) {
 543             fMinTime = delta;
 544         }
 545
 546         if ((delta.compareTo(fMaxTime, true) > 0) && (delta.compareTo(TmfTimestamp.ZERO, false) > 0)) {
 547             fMaxTime = delta;
 548         }
 549     }
 550
 551     /**
 552      * Builds the time array based on the list of graph nodes.
 553      *
 554      * @return the time array else empty list.
 555      */
 556     protected List<SDTimeEvent> buildTimeArray() {
 557         if (!hasChildren()) {
 558             return new ArrayList<>();
 559         }
 560
 561         Iterator<String> it = getForwardSortMap().keySet().iterator();
 562         List<SDTimeEvent> timeArray = new ArrayList<>();
 563         while (it.hasNext()) {
 564             String nodeType = it.next();
 565             List<GraphNode> list = getNodeMap().get(nodeType);
 566             for (int i = 0; i < list.size(); i++) {
 567                 Object timedNode = list.get(i);
 568                 if ((timedNode instanceof ITimeRange) && ((ITimeRange) timedNode).hasTimeInfo()) {
 569                     int event = list.get(i).getStartOccurrence();
 570                     ITmfTimestamp time = ((ITimeRange) list.get(i)).getStartTime();
 571                     SDTimeEvent f = new SDTimeEvent(time, event, (ITimeRange) list.get(i));
 572                     timeArray.add(f);
 573                     if (event != list.get(i).getEndOccurrence()) {
 574                         event = (list.get(i)).getEndOccurrence();
 575                         time = ((ITimeRange) list.get(i)).getEndTime();
 576                         f = new SDTimeEvent(time, event, (ITimeRange) list.get(i));
 577                         timeArray.add(f);
 578                     }
 579                 }
 580             }
 581         }
 582         return timeArray;
 583     }
 584
 585     @Override
 586     public String getArrayId() {
 587         return null;
 588     }
 589
 590     @Override
 591     public boolean contains(int x, int y) {
 592         return false;
 593     }
 594
 595     /**
 596      * @return true if frame has time info else false
 597      * @since 2.0
 598      */
 599     public boolean hasTimeInfo() {
 600         return fHasTimeInfo;
 601     }
 602
 603     /**
 604      * Sets the flag whether the frame has time info or not
 605      * @since 2.0
 606      * @param hasTimeInfo
 607      *          true if frame has time info else false
 608      */
 609     public void setHasTimeInfo(boolean hasTimeInfo) {
 610         fHasTimeInfo = hasTimeInfo;
 611     }
 612
 613     /**
 614      * Sets the flag for minimum and maximum computation.
 615      * @param computeMinMax
 616      *          true if mininum and maximum time needs to be calculated else false
 617      * @since 2.0
 618      */
 619     public void setComputeMinMax(boolean computeMinMax) {
 620         fComputeMinMax = computeMinMax;
 621     }
 622
 623     /**
 624      * Sets the initialization flag for SD minimum.
 625      *
 626      * @param initSDMin
 627      *          the flag to set
 628      * @since 2.0
 629      */
 630     public void setInitSDMin(boolean initSDMin) {
 631         fInitSDMin = initSDMin;
 632     }
 633 }