tmf: Simple warning fixes in tmf.ui and tests
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / views / uml2sd / core / Lifeline.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.List;
18
19 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IColor;
20 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IGC;
21 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IImage;
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 * Lifeline is the UML2 lifeline graphical representation.<br>
27 * Each lifeline owns a set of event occurrences. An event occurrence is the base element in UML2 to set an event in a
28 * sequence diagram.<br>
29 * Event occurrence define the drawing order of graph node along a lifeline. In this lifeline implementation, event
30 * occurrences are just integer index. The event occurrences with the same value on different lifelines will correspond
31 * the same y coordinate value.
32 *
33 * @version 1.0
34 * @author sveyrier
35 *
36 */
37 public class Lifeline extends GraphNode {
38 // ------------------------------------------------------------------------
39 // Constants
40 // ------------------------------------------------------------------------
41 /**
42 * The life line tag.
43 */
44 public static final String LIFELINE_TAG = "Lifeline"; //$NON-NLS-1$
45
46 // ------------------------------------------------------------------------
47 // Attribute
48 // ------------------------------------------------------------------------
49 /**
50 * The lifeline position in the containing frame
51 */
52 protected int fIndexInFrame = 0;
53 /**
54 * The frame where the lifeline is drawn
55 */
56 protected Frame fFrame = null;
57 /**
58 * The current event occurrence created in the lifeline
59 */
60 protected int fEventOccurrence = 0;
61 /**
62 * The lifeline category.
63 */
64 protected int fCategory = -1;
65 /**
66 * Flag whether lifeline has time information available or not
67 */
68 protected boolean fHasTimeInfo = false;
69
70 // ------------------------------------------------------------------------
71 // Constructors
72 // ------------------------------------------------------------------------
73 /**
74 * Default constructor
75 */
76 public Lifeline() {
77 fPrefId = ISDPreferences.PREF_LIFELINE;
78 }
79
80 // ------------------------------------------------------------------------
81 // Methods
82 // ------------------------------------------------------------------------
83 /*
84 * (non-Javadoc)
85 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getX()
86 */
87 @Override
88 public int getX() {
89 return Metrics.FRAME_H_MARGIN + Metrics.LIFELINE_H_MAGIN + (fIndexInFrame - 1) * Metrics.swimmingLaneWidth();
90 }
91
92 /*
93 * (non-Javadoc)
94 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getY()
95 */
96 @Override
97 public int getY() {
98 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;
99 }
100
101 /*
102 * (non-Javadoc)
103 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getWidth()
104 */
105 @Override
106 public int getWidth() {
107 return Metrics.getLifelineWidth();
108 }
109
110 /*
111 * (non-Javadoc)
112 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode#getHeight()
113 */
114 @Override
115 public int getHeight() {
116 // Set room for two text lines
117 return Metrics.getLifelineFontHeigth()/** 2 */
118 + 2 * Metrics.LIFELINE_NAME_H_MARGIN;
119 }
120
121 /**
122 * Set the lifeline category for this lifeline.
123 *
124 * @param arrayIndex the index of the category to use
125 * @see Frame#setLifelineCategories(LifelineCategories[])
126 */
127 public void setCategory(int arrayIndex) {
128 fCategory = arrayIndex;
129 }
130
131 /**
132 * Returns the tooltip text for the lifeline. It is the combination between the category name(if any) and the
133 * lifeline name
134 *
135 * @return the tooltip text
136 */
137 public String getToolTipText() {
138 if (fCategory >= 0) {
139 LifelineCategories[] categories = fFrame.getLifelineCategories();
140 if (fCategory < categories.length) {
141 return categories[fCategory].getName() + " " + getName(); //$NON-NLS-1$
142 }
143 }
144 return ""; //$NON-NLS-1$
145 }
146
147 /**
148 * Returns the index of the first visible Execution Occurrence in the execution occurrence array.<br>
149 * Execution Occurrences are Y ordered in this array
150 *
151 * @return the first visible Execution Occurrence
152 */
153 public int getExecOccurrenceDrawIndex() {
154 if (!fHasChilden) {
155 return 0;
156 }
157 if (fIndexes.get(BasicExecutionOccurrence.EXEC_OCC_TAG) != null) {
158 return fIndexes.get(BasicExecutionOccurrence.EXEC_OCC_TAG).intValue();
159 }
160 return 0;
161 }
162
163 /**
164 * Set the frame on which this lifeline must be drawn
165 *
166 * @param parentFrame
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 }
This page took 0.063445 seconds and 6 git commands to generate.