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

   1 /**********************************************************************
   2  * Copyright (c) 2005, 2008 IBM Corporation and others.
   3  * Copyright (c) 2011, 2012 Ericsson.
   4  *
   5  * All rights reserved.   This program and the accompanying materials
   6  * are made available under the terms of the Eclipse Public License v1.0
   7  * which accompanies this distribution, and is available at
   8  * http://www.eclipse.org/legal/epl-v10.html
   9  *
  10  * Contributors:
  11  * IBM - Initial API and implementation
  12  * Bernd Hufmann - Updated for TMF
  13  **********************************************************************/
  14 package org.eclipse.linuxtools.tmf.ui.views.uml2sd.core;
  15
  16 import java.util.ArrayList;
  17 import java.util.Iterator;
  18 import java.util.List;
  19
  20 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
  21 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
  22 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IGC;
  23 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.preferences.ISDPreferences;
  24 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.preferences.SDViewPref;
  25
  26 /**
  27  * The Frame class is the base sequence diagram graph nodes container.<br>
  28  * For instance, only one frame can be drawn in the View.<br>
  29  * Lifelines, Messages and Stop which are supposed to represent a Sequence diagram are drawn in a Frame.<br>
  30  * Only the graph node added to their representing list will be drawn.
  31  *
  32  * The lifelines are appended along the X axsis when added in a frame.<br>
  33  * The syncMessages are ordered along the Y axsis depending on the event occurrence they are attached to.<br>
  34  *
  35  * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Lifeline Lifeline for more event occurence details
  36  * @author sveyrier
  37  * @version 1.0
  38  */
  39 public class BasicFrame extends GraphNode {
  40
  41     // ------------------------------------------------------------------------
  42     // Attributes
  43     // ------------------------------------------------------------------------
  44
  45     /**
  46      * Contains the max elapsed time between two consecutive messages in the whole frame
  47      */
  48     protected ITmfTimestamp fMaxTime = new TmfTimestamp(0);
  49     /**
  50      * Contains the min elapsed time between two consecutive messages in the whole frame
  51      */
  52     protected ITmfTimestamp fMinTime = new TmfTimestamp(0);
  53     /**
  54      * Indicate if the min and max elapsed time between two consecutive messages in the whole frame need to be computed
  55      */
  56     protected boolean fComputeMinMax = true;
  57     /**
  58      * Store the preference set by the user regarding the external time. This flag is used determine if the min and max
  59      * need to be recomputed in case this preference is changed.
  60      */
  61     protected boolean fLastExternalTimePref = SDViewPref.getInstance().excludeExternalTime();
  62     /**
  63      * The greater event occurrence created on graph nodes drawn in this Frame This directly impact the Frame height
  64      */
  65     protected int fVerticalIndex = 0;
  66     /**
  67      * The index along the x axis where the next lifeline will is drawn This directly impact the Frame width
  68      */
  69     protected int fHorizontalIndex = 0;
  70     /**
  71      * The time information flag.
  72      */
  73     protected boolean fHasTimeInfo = false;
  74     /**
  75      * The current Frame visible area - x coordinates
  76      */
  77     protected int fVisibleAreaX;
  78     /**
  79      * The current Frame visible area - y coordinates
  80      */
  81     protected int fVisibleAreaY;
  82     /**
  83      * The current Frame visible area - width
  84      */
  85     protected int fVisibleAreaWidth;
  86     /**
  87      * The current Frame visible area - height
  88      */
  89     protected int fVisibleAreaHeight;
  90     /**
  91      * The event occurrence spacing (-1 for none)
  92      */
  93     protected int fForceEventOccurrenceSpacing = -1;
  94     /**
  95      * Flag to indicate customized minumum and maximum.
  96      */
  97     protected boolean fCustomMinMax = false;
  98     /**
  99      * The minimum time between messages of the sequence diagram frame.
 100      */
 101     protected ITmfTimestamp fMinSDTime = new TmfTimestamp();
 102     /**
 103      * The maximum time between messages of the sequence diagram frame.
 104      */
 105     protected ITmfTimestamp fMaxSDTime = new TmfTimestamp();
 106     /**
 107      * Flag to indicate that initial minimum has to be computed.
 108      */
 109     protected boolean fInitSDMin = true;
 110
 111     // ------------------------------------------------------------------------
 112     // Constructors
 113     // ------------------------------------------------------------------------
 114
 115     /**
 116      * Creates an empty frame.
 117      */
 118     public BasicFrame() {
 119         Metrics.setForcedEventSpacing(fForceEventOccurrenceSpacing);
 120     }
 121
 122     // ------------------------------------------------------------------------
 123     // Methods
 124     // ------------------------------------------------------------------------
 125
 126     /**
 127      *
 128      * Returns the greater event occurence known by the Frame
 129      *
 130      * @return the greater event occurrence
 131      */
 132     protected int getMaxEventOccurrence() {
 133         return fVerticalIndex;
 134     }
 135
 136     /**
 137      * Set the greater event occurrence created in GraphNodes included in the frame
 138      *
 139      * @param eventOccurrence the new greater event occurrence
 140      */
 141     protected void setMaxEventOccurrence(int eventOccurrence) {
 142         fVerticalIndex = eventOccurrence;
 143     }
 144
 145     /**
 146      * This method increase the lifeline place holder The return value is usually assign to a lifeline. This can be used
 147      * to set the lifelines drawing order. Also, calling this method two times and assigning only the last given index
 148      * to a lifeline will increase this lifeline draw spacing (2 times the default spacing) from the last added
 149      * lifeline.
 150      *
 151      * @return a new lifeline index
 152      */
 153     protected int getNewHorizontalIndex() {
 154         return ++fHorizontalIndex;
 155     }
 156
 157     /**
 158      * Returns the current horizontal index
 159      *
 160      * @return the current horizontal index
 161      * @see Frame#getNewHorizontalIndex() for horizontal index description
 162      */
 163     protected int getHorizontalIndex() {
 164         return fHorizontalIndex;
 165     }
 166
 167     /*
 168      * (non-Javadoc)
 169      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#addNode(org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode)
 170      */
 171     @Override
 172     public void addNode(GraphNode nodeToAdd) {
 173         fComputeMinMax = true;
 174         super.addNode(nodeToAdd);
 175     }
 176
 177     /*
 178      * (non-Javadoc)
 179      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getX()
 180      */
 181     @Override
 182     public int getX() {
 183         return Metrics.FRAME_H_MARGIN;
 184     }
 185
 186
 187     /*
 188      * (non-Javadoc)
 189      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getY()
 190      */
 191     @Override
 192     public int getY() {
 193         return Metrics.FRAME_V_MARGIN;
 194     }
 195
 196     /*
 197      * (non-Javadoc)
 198      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getWidth()
 199      */
 200     @Override
 201     public int getWidth() {
 202         if (fHorizontalIndex == 0) {
 203             return 3 * Metrics.swimmingLaneWidth() + Metrics.LIFELINE_H_MAGIN * 2 - Metrics.FRAME_H_MARGIN - Metrics.LIFELINE_SPACING / 2;
 204         }
 205         return fHorizontalIndex * Metrics.swimmingLaneWidth() + Metrics.LIFELINE_H_MAGIN * 2 + 1 - Metrics.LIFELINE_SPACING;
 206     }
 207
 208     /*
 209      * (non-Javadoc)
 210      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getHeight()
 211      */
 212     @Override
 213     public int getHeight() {
 214         // The Frame height depends on the maximum number of messages added to a lifeline
 215         if (fVerticalIndex == 0) {
 216             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
 217                     + Metrics.LIFELINE_NAME_H_MARGIN + Metrics.FRAME_NAME_H_MARGIN + Metrics.getLifelineFontHeigth() * 2;
 218         }
 219         if (fForceEventOccurrenceSpacing >= 0) {
 220             Metrics.setForcedEventSpacing(fForceEventOccurrenceSpacing);
 221         }
 222         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
 223                 + Metrics.LIFELINE_NAME_H_MARGIN + Metrics.FRAME_NAME_H_MARGIN + Metrics.getLifelineFontHeigth() * 2;
 224     }
 225
 226     /**
 227      * Returns the graph node which contains the point given in parameter for the given graph node list and starting the
 228      * iteration at the given index<br>
 229      * WARNING: Only graph nodes with smaller coordinates than the current visible area can be returned.<br>
 230      *
 231      * @param x the x coordinate of the point to test
 232      * @param y the y coordinate of the point to test
 233      * @param list the list to search in
 234      * @param fromIndex list browsing starting point
 235      * @return the graph node containing the point given in parameter, null otherwise
 236      *
 237      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getNodeFromListAt(int, int, java.util.List, int)
 238      */
 239     @Override
 240     protected GraphNode getNodeFromListAt(int x, int y, List<GraphNode> list, int fromIndex) {
 241         if (list == null) {
 242             return null;
 243         }
 244         for (int i = fromIndex; i < list.size(); i++) {
 245             GraphNode node = list.get(i);
 246             // only lifeline list is x ordered
 247             // Stop browsing the list if the node is outside the visible area
 248             // all others nodes will be not visible
 249             if ((node instanceof Lifeline) && (node.getX() > fVisibleAreaX + fVisibleAreaWidth)) {
 250                 break;
 251             }
 252             if (node.getHeight() < 0) {
 253                 if (node.getY() + node.getHeight() > fVisibleAreaY + fVisibleAreaHeight) {
 254                     break;
 255                 }
 256             } else {
 257                 if (node.getY() > fVisibleAreaY + fVisibleAreaHeight) {
 258                     break;
 259                 }
 260             }
 261             if (node.contains(x, y)) {
 262                 return node;
 263             }
 264         }
 265         return null;
 266     }
 267
 268     /**
 269      * Draw the Frame rectangle
 270      *
 271      * @param context the context to draw to
 272      */
 273     protected void drawFrame(IGC context) {
 274
 275         ISDPreferences pref = SDViewPref.getInstance();
 276
 277         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME));
 278         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_FRAME));
 279
 280         int x = getX();
 281         int y = getY();
 282         int w = getWidth();
 283         int h = getHeight();
 284
 285         // Draw the frame main rectangle
 286         context.fillRectangle(x, y, w, h);
 287         context.drawRectangle(x, y, w, h);
 288
 289         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME_NAME));
 290         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_FRAME_NAME));
 291         context.setFont(pref.getFont(ISDPreferences.PREF_FRAME_NAME));
 292
 293         int nameWidth = context.textExtent(getName()) + 2 * Metrics.FRAME_NAME_V_MARGIN;
 294         int nameHeight = Metrics.getFrameFontHeigth() + +Metrics.FRAME_NAME_H_MARGIN * 2;
 295
 296         // Draw the frame name area
 297         if (nameWidth > w) {
 298             nameWidth = w;
 299         }
 300
 301         int[] points = { x, y, x + nameWidth, y, x + nameWidth, y - 11 + nameHeight, x - 11 + nameWidth, y + nameHeight, x, y + nameHeight, x, y + nameHeight };
 302         context.fillPolygon(points);
 303         context.drawPolygon(points);
 304         context.drawLine(x, y, x, y + nameHeight);
 305
 306         context.setForeground(pref.getFontColor(ISDPreferences.PREF_FRAME_NAME));
 307         context.drawTextTruncatedCentred(getName(), x, y, nameWidth - 11, nameHeight, false);
 308
 309         context.setBackground(pref.getBackGroundColor(ISDPreferences.PREF_FRAME));
 310         context.setForeground(pref.getForeGroundColor(ISDPreferences.PREF_FRAME));
 311     }
 312
 313     /*
 314      * (non-Javadoc)
 315      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#draw(org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IGC)
 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             fComputeMinMax = true;
 401         }
 402         if ((fComputeMinMax) && (!fCustomMinMax)) {
 403             computeMinMax();
 404             fComputeMinMax = 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         fComputeMinMax = 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             fComputeMinMax = true;
 451         }
 452         if (fComputeMinMax) {
 453             computeMinMax();
 454             fComputeMinMax = 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             fComputeMinMax = 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 (!fHasChilden) {
 558             return new ArrayList<SDTimeEvent>();
 559         }
 560
 561         Iterator<String> it = fForwardSort.keySet().iterator();
 562         List<SDTimeEvent> timeArray = new ArrayList<SDTimeEvent>();
 563         while (it.hasNext()) {
 564             String nodeType = it.next();
 565             List<GraphNode> list = fNodes.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 = ((AsyncMessage) 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     /*
 586      * (non-Javadoc)
 587      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getArrayId()
 588      */
 589     @Override
 590     public String getArrayId() {
 591         return null;
 592     }
 593
 594     /*
 595      * (non-Javadoc)
 596      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#contains(int, int)
 597      */
 598     @Override
 599     public boolean contains(int x, int y) {
 600         return false;
 601     }
 602 }