/*******************************************************************************
- * Copyright (c) 2011, 2012 Ericsson
- *
+ * Copyright (c) 2011, 2013 Ericsson
+ *
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
- *
+ *
* Contributors:
* Francois Chouinard - Initial API and implementation
* Bernd Hufmann - Changed to updated histogram data model
- * Francois Chouinard - Initial API and implementation
+ * Francois Chouinard - Reformat histogram labels on format change
+ * Patrick Tasse - Support selection range
*******************************************************************************/
package org.eclipse.linuxtools.tmf.ui.views.histogram;
+import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
+import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
+import org.eclipse.linuxtools.tmf.core.signal.TmfTimestampFormatUpdateSignal;
+import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestampDelta;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.linuxtools.tmf.ui.views.TmfView;
+import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
+import org.eclipse.swt.events.FocusAdapter;
+import org.eclipse.swt.events.FocusEvent;
+import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
+import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackListener;
+import org.eclipse.swt.events.MouseWheelListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
/**
- * <b><u>Histogram</u></b>
- * <p>
- * Re-usable histogram widget with the following features:
+ * Re-usable histogram widget.
+ *
+ * It has the following features:
* <ul>
* <li>Y-axis labels displaying min/max count values
* <li>X-axis labels displaying time range
* <li>end of the time range
* <li>number of events in that time range
* </ul>
+ *
+ * @version 1.1
+ * @author Francois Chouinard
*/
-public abstract class Histogram implements ControlListener, PaintListener, KeyListener, MouseListener, MouseTrackListener, IHistogramModelListener {
+public abstract class Histogram implements ControlListener, PaintListener, KeyListener, MouseListener, MouseMoveListener, MouseTrackListener, IHistogramModelListener {
// ------------------------------------------------------------------------
// Constants
// Histogram colors
private final Color fBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_WHITE);
- private final Color fCurrentEventColor = Display.getCurrent().getSystemColor(SWT.COLOR_RED);
+ private final Color fSelectionForegroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_BLUE);
+ private final Color fSelectionBackgroundColor = Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
private final Color fLastEventColor = Display.getCurrent().getSystemColor(SWT.COLOR_DARK_RED);
private final Color fHistoBarColor = new Color(Display.getDefault(), 74, 112, 139);
+ private final Color fLostEventColor = new Color(Display.getCurrent(), 208, 62, 120);
+ private final Color fFillColor = Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
+ private final Color fTimeRangeColor = new Color(Display.getCurrent(), 255, 128, 0);
- // Timestamp scale (nanosecond)
- public static final byte TIME_SCALE = -9;
-
- public static final int HISTOGRAM_BAR_WIDTH = 1;
+ // Drag states
+ /**
+ * No drag in progress
+ * @since 2.2
+ */
+ protected final int DRAG_NONE = 0;
+ /**
+ * Drag the selection
+ * @since 2.2
+ */
+ protected final int DRAG_SELECTION = 1;
+ /**
+ * Drag the time range
+ * @since 2.2
+ */
+ protected final int DRAG_RANGE = 2;
+ /**
+ * Drag the zoom range
+ * @since 2.2
+ */
+ protected final int DRAG_ZOOM = 3;
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
- // Owner view
+ /**
+ * The parent TMF view.
+ */
protected TmfView fParentView;
+ private Composite fComposite;
+ private Font fFont;
+
// Histogram text fields
private Text fMaxNbEventsText;
private Text fMinNbEventsText;
private Text fTimeRangeStartText;
private Text fTimeRangeEndText;
- // Histogram drawing area
+ /**
+ * Histogram drawing area
+ */
protected Canvas fCanvas;
- // Data model
+ /**
+ * The histogram data model.
+ */
protected final HistogramDataModel fDataModel;
+
+ /**
+ * The histogram data model scaled to current resolution and screen width.
+ */
protected HistogramScaledData fScaledData;
- protected long fCurrentEventTime = 0;
+ /**
+ * The current event value
+ */
+ protected long fCurrentEventTime = 0L;
+
+ /**
+ * The current selection begin time
+ */
+ private long fSelectionBegin = 0L;
+
+ /**
+ * The current selection end time
+ */
+ private long fSelectionEnd = 0L;
+
+ /**
+ * The drag state
+ * @see #DRAG_NONE
+ * @see #DRAG_SELECTION
+ * @see #DRAG_RANGE
+ * @see #DRAG_ZOOM
+ * @since 2.2
+ */
+ protected int fDragState = DRAG_NONE;
+
+ /**
+ * The button that started a mouse drag, or 0 if no drag in progress
+ * @since 2.2
+ */
+ protected int fDragButton = 0;
+
+ /**
+ * The bucket display offset
+ */
+ private int fOffset = 0;
// ------------------------------------------------------------------------
// Construction
// ------------------------------------------------------------------------
+ /**
+ * Full constructor.
+ *
+ * @param view A reference to the parent TMF view.
+ * @param parent A parent composite
+ */
public Histogram(final TmfView view, final Composite parent) {
fParentView = view;
- createWidget(parent);
+ fComposite = createWidget(parent);
fDataModel = new HistogramDataModel();
fDataModel.addHistogramListener(this);
clear();
fCanvas.addKeyListener(this);
fCanvas.addMouseListener(this);
fCanvas.addMouseTrackListener(this);
+ fCanvas.addMouseMoveListener(this);
+
+ TmfSignalManager.register(this);
}
+ /**
+ * Dispose resources and unregisters listeners.
+ */
public void dispose() {
+ TmfSignalManager.deregister(this);
+
fHistoBarColor.dispose();
+ fLastEventColor.dispose();
+ fTimeRangeColor.dispose();
fDataModel.removeHistogramListener(this);
}
- private void createWidget(final Composite parent) {
+ private Composite createWidget(final Composite parent) {
final Color labelColor = parent.getBackground();
- final Font fFont = adjustFont(parent);
+ fFont = adjustFont(parent);
final int initalWidth = 10;
gridData.horizontalAlignment = SWT.FILL;
gridData.verticalAlignment = SWT.FILL;
gridData.grabExcessHorizontalSpace = true;
+ gridData.grabExcessVerticalSpace = true;
composite.setLayoutData(gridData);
// Y-axis max event
fMaxNbEventsText.setLayoutData(gridData);
// Histogram itself
+ Composite canvasComposite = new Composite(composite, SWT.BORDER);
gridData = new GridData();
gridData.horizontalSpan = 2;
gridData.verticalSpan = 2;
gridData.horizontalAlignment = SWT.FILL;
gridData.verticalAlignment = SWT.FILL;
+ gridData.heightHint = 0;
+ gridData.widthHint = 0;
gridData.grabExcessHorizontalSpace = true;
- fCanvas = new Canvas(composite, SWT.BORDER | SWT.DOUBLE_BUFFERED);
- fCanvas.setLayoutData(gridData);
+ gridData.grabExcessVerticalSpace = true;
+ canvasComposite.setLayoutData(gridData);
+ canvasComposite.setLayout(new FillLayout());
+ fCanvas = new Canvas(canvasComposite, SWT.DOUBLE_BUFFERED);
// Y-axis min event (always 0...)
gridData = new GridData();
gridData = new GridData(initalWidth, SWT.DEFAULT);
gridData.horizontalAlignment = SWT.RIGHT;
gridData.verticalAlignment = SWT.BOTTOM;
- final Text dummyText = new Text(composite, SWT.READ_ONLY);
- dummyText.setFont(fFont);
- dummyText.setBackground(labelColor);
- dummyText.setEditable(false);
- dummyText.setText(""); //$NON-NLS-1$
- dummyText.setLayoutData(gridData);
+ final Label dummyLabel = new Label(composite, SWT.NONE);
+ dummyLabel.setLayoutData(gridData);
// Window range start time
gridData = new GridData();
fTimeRangeStartText = new Text(composite, SWT.READ_ONLY);
fTimeRangeStartText.setFont(fFont);
fTimeRangeStartText.setBackground(labelColor);
- fTimeRangeStartText.setText(HistogramUtils.nanosecondsToString(0));
fTimeRangeStartText.setLayoutData(gridData);
// Window range end time
fTimeRangeEndText = new Text(composite, SWT.READ_ONLY);
fTimeRangeEndText.setFont(fFont);
fTimeRangeEndText.setBackground(labelColor);
- fTimeRangeEndText.setText(HistogramUtils.nanosecondsToString(0));
fTimeRangeEndText.setLayoutData(gridData);
+
+ FocusListener listener = new FocusAdapter() {
+ @Override
+ public void focusGained(FocusEvent e) {
+ fCanvas.setFocus();
+ }
+ };
+ fMaxNbEventsText.addFocusListener(listener);
+ fMinNbEventsText.addFocusListener(listener);
+ fTimeRangeStartText.addFocusListener(listener);
+ fTimeRangeEndText.addFocusListener(listener);
+
+ return composite;
}
- private Font adjustFont(final Composite composite) {
+ private static Font adjustFont(final Composite composite) {
// Reduce font size for a more pleasing rendering
final int fontSizeAdjustment = -2;
final Font font = composite.getFont();
// Accessors
// ------------------------------------------------------------------------
+ /**
+ * Returns the start time (equal first bucket time)
+ * @return the start time.
+ */
public long getStartTime() {
return fDataModel.getFirstBucketTime();
}
+ /**
+ * Returns the end time.
+ * @return the end time.
+ */
public long getEndTime() {
return fDataModel.getEndTime();
}
+ /**
+ * Returns the time limit (end of last bucket)
+ * @return the time limit.
+ */
public long getTimeLimit() {
return fDataModel.getTimeLimit();
}
+ /**
+ * Returns a data model reference.
+ * @return data model.
+ */
public HistogramDataModel getDataModel() {
return fDataModel;
}
+ /**
+ * Returns the text control for the maximum of events in one bar
+ *
+ * @return the text control
+ * @since 2.2
+ */
+ public Text getMaxNbEventsText() {
+ return fMaxNbEventsText;
+ }
+
// ------------------------------------------------------------------------
// Operations
// ------------------------------------------------------------------------
- public abstract void updateTimeRange(long startTime, long endTime);
+ /**
+ * Updates the time range.
+ * @param startTime A start time
+ * @param endTime A end time.
+ */
+ public void updateTimeRange(long startTime, long endTime) {
+ if (fDragState == DRAG_NONE) {
+ ((HistogramView) fParentView).updateTimeRange(startTime, endTime);
+ }
+ }
/**
* Clear the histogram and reset the data
*/
public void clear() {
fDataModel.clear();
- fScaledData = null;
+ synchronized (fDataModel) {
+ fScaledData = null;
+ }
}
/**
* Increase the histogram bucket corresponding to [timestamp]
- *
- * @param timestamp
+ *
+ * @param eventCount The new event count
+ * @param timestamp The latest timestamp
*/
public void countEvent(final long eventCount, final long timestamp) {
fDataModel.countEvent(eventCount, timestamp);
/**
* Sets the current event time and refresh the display
- *
- * @param timestamp
+ *
+ * @param timestamp The time of the current event
+ * @deprecated As of 2.1, use {@link #setSelection(long, long)}
*/
+ @Deprecated
public void setCurrentEvent(final long timestamp) {
- fCurrentEventTime = (timestamp > 0) ? timestamp : 0;
- fDataModel.setCurrentEventNotifyListeners(timestamp);
+ fSelectionBegin = (timestamp > 0) ? timestamp : 0;
+ fSelectionEnd = (timestamp > 0) ? timestamp : 0;
+ fDataModel.setSelectionNotifyListeners(timestamp, timestamp);
+ }
+
+ /**
+ * Sets the current selection time range and refresh the display
+ *
+ * @param beginTime The begin time of the current selection
+ * @param endTime The end time of the current selection
+ * @since 2.1
+ */
+ public void setSelection(final long beginTime, final long endTime) {
+ fSelectionBegin = (beginTime > 0) ? beginTime : 0;
+ fSelectionEnd = (endTime > 0) ? endTime : 0;
+ fDataModel.setSelectionNotifyListeners(beginTime, endTime);
}
/**
* Computes the timestamp of the bucket at [offset]
- *
+ *
* @param offset offset from the left on the histogram
* @return the start timestamp of the corresponding bucket
*/
public synchronized long getTimestamp(final int offset) {
assert offset > 0 && offset < fScaledData.fWidth;
try {
- return fDataModel.getFirstBucketTime() + fScaledData.fBucketDuration * offset;
+ return fScaledData.fFirstBucketTime + fScaledData.fBucketDuration * offset;
} catch (final Exception e) {
return 0; // TODO: Fix that racing condition (NPE)
}
/**
* Computes the offset of the timestamp in the histogram
- *
+ *
* @param timestamp the timestamp
* @return the offset of the corresponding bucket (-1 if invalid)
*/
public synchronized int getOffset(final long timestamp) {
- if (timestamp < fDataModel.getFirstBucketTime() || timestamp > fDataModel.getEndTime())
+ if (timestamp < fDataModel.getFirstBucketTime() || timestamp > fDataModel.getEndTime()) {
return -1;
+ }
return (int) ((timestamp - fDataModel.getFirstBucketTime()) / fScaledData.fBucketDuration);
}
+ /**
+ * Set the bucket display offset
+ *
+ * @param offset
+ * the bucket display offset
+ * @since 2.2
+ */
+ protected void setOffset(final int offset) {
+ fOffset = offset;
+ }
+
/**
* Move the currently selected bar cursor to a non-empty bucket.
- *
+ *
* @param keyCode the SWT key code
*/
protected void moveCursor(final int keyCode) {
- if (fScaledData.fCurrentBucket == HistogramScaledData.OUT_OF_RANGE_BUCKET)
- return;
-
int index;
switch (keyCode) {
- case SWT.HOME:
- index = 0;
- while (index < fScaledData.fLastBucket && fScaledData.fData[index] == 0)
- index++;
- if (index < fScaledData.fLastBucket)
- fScaledData.fCurrentBucket = index;
- break;
-
- case SWT.ARROW_RIGHT:
- index = fScaledData.fCurrentBucket + 1;
- while (index < fScaledData.fWidth && fScaledData.fData[index] == 0)
- index++;
- if (index < fScaledData.fLastBucket)
- fScaledData.fCurrentBucket = index;
- break;
-
- case SWT.END:
- index = fScaledData.fLastBucket;
- while (index >= 0 && fScaledData.fData[index] == 0)
- index--;
- if (index >= 0)
- fScaledData.fCurrentBucket = index;
- break;
-
- case SWT.ARROW_LEFT:
- index = fScaledData.fCurrentBucket - 1;
- while (index >= 0 && fScaledData.fData[index] == 0)
- index--;
- if (index >= 0)
- fScaledData.fCurrentBucket = index;
- break;
-
- default:
- return;
+ case SWT.HOME:
+ index = 0;
+ while (index < fScaledData.fLastBucket && fScaledData.fData[index] == 0) {
+ index++;
+ }
+ if (index < fScaledData.fLastBucket) {
+ fScaledData.fSelectionBeginBucket = index;
+ }
+ break;
+
+ case SWT.ARROW_RIGHT:
+ index = Math.max(0, fScaledData.fSelectionBeginBucket + 1);
+ while (index < fScaledData.fWidth && fScaledData.fData[index] == 0) {
+ index++;
+ }
+ if (index < fScaledData.fLastBucket) {
+ fScaledData.fSelectionBeginBucket = index;
+ }
+ break;
+
+ case SWT.END:
+ index = fScaledData.fLastBucket;
+ while (index >= 0 && fScaledData.fData[index] == 0) {
+ index--;
+ }
+ if (index >= 0) {
+ fScaledData.fSelectionBeginBucket = index;
+ }
+ break;
+
+ case SWT.ARROW_LEFT:
+ index = Math.min(fScaledData.fLastBucket - 1, fScaledData.fSelectionBeginBucket - 1);
+ while (index >= 0 && fScaledData.fData[index] == 0) {
+ index--;
+ }
+ if (index >= 0) {
+ fScaledData.fSelectionBeginBucket = index;
+ }
+ break;
+
+ default:
+ return;
}
- updateCurrentEventTime();
+ fScaledData.fSelectionEndBucket = fScaledData.fSelectionBeginBucket;
+ fSelectionBegin = getTimestamp(fScaledData.fSelectionBeginBucket);
+ fSelectionEnd = fSelectionBegin;
+ updateSelectionTime();
}
/**
*/
@Override
public void modelUpdated() {
- if (!fCanvas.isDisposed() && fCanvas.getDisplay() != null)
+ if (!fCanvas.isDisposed() && fCanvas.getDisplay() != null) {
fCanvas.getDisplay().asyncExec(new Runnable() {
@Override
public void run() {
// Retrieve and normalize the data
final int canvasWidth = fCanvas.getBounds().width;
final int canvasHeight = fCanvas.getBounds().height;
- if (canvasWidth <= 0 || canvasHeight <= 0)
+ if (canvasWidth <= 0 || canvasHeight <= 0) {
return;
- fDataModel.setCurrentEvent(fCurrentEventTime);
- fScaledData = fDataModel.scaleTo(canvasWidth, canvasHeight, HISTOGRAM_BAR_WIDTH);
- synchronized(fScaledData) {
+ }
+ fDataModel.setSelection(fSelectionBegin, fSelectionEnd);
+ fScaledData = fDataModel.scaleTo(canvasWidth, canvasHeight, 1);
+ synchronized (fDataModel) {
if (fScaledData != null) {
fCanvas.redraw();
// Display histogram and update X-,Y-axis labels
- fTimeRangeStartText.setText(HistogramUtils.nanosecondsToString(fDataModel.getFirstBucketTime()));
- fTimeRangeEndText.setText(HistogramUtils.nanosecondsToString(fDataModel.getEndTime()));
- fMaxNbEventsText.setText(Long.toString(fScaledData.fMaxValue));
+ updateRangeTextControls();
+ long maxNbEvents = HistogramScaledData.hideLostEvents ? fScaledData.fMaxValue : fScaledData.fMaxCombinedValue;
+ fMaxNbEventsText.setText(Long.toString(maxNbEvents));
// The Y-axis area might need to be re-sized
+ GridData gd = (GridData) fMaxNbEventsText.getLayoutData();
+ gd.widthHint = Math.max(gd.widthHint, fMaxNbEventsText.computeSize(SWT.DEFAULT, SWT.DEFAULT).x);
fMaxNbEventsText.getParent().layout();
}
}
}
}
});
+ }
+ }
+
+ /**
+ * Add a mouse wheel listener to the histogram
+ * @param listener the mouse wheel listener
+ * @since 2.0
+ */
+ public void addMouseWheelListener(MouseWheelListener listener) {
+ fCanvas.addMouseWheelListener(listener);
+ }
+
+ /**
+ * Remove a mouse wheel listener from the histogram
+ * @param listener the mouse wheel listener
+ * @since 2.0
+ */
+ public void removeMouseWheelListener(MouseWheelListener listener) {
+ fCanvas.removeMouseWheelListener(listener);
}
// ------------------------------------------------------------------------
// Helper functions
// ------------------------------------------------------------------------
- private void updateCurrentEventTime() {
- final long bucketStartTime = getTimestamp(fScaledData.fCurrentBucket);
- ((HistogramView) fParentView).updateCurrentEventTime(bucketStartTime);
+ private void updateSelectionTime() {
+ if (fSelectionBegin > fSelectionEnd) {
+ long end = fSelectionBegin;
+ fSelectionBegin = fSelectionEnd;
+ fSelectionEnd = end;
+ }
+ ((HistogramView) fParentView).updateSelectionTime(fSelectionBegin, fSelectionEnd);
+ }
+
+ /**
+ * Update the range text controls
+ */
+ private void updateRangeTextControls() {
+ if (fDataModel != null && fDataModel.getStartTime() < fDataModel.getEndTime()) {
+ fTimeRangeStartText.setText(TmfTimestampFormat.getDefaulTimeFormat().format(fDataModel.getStartTime()));
+ fTimeRangeEndText.setText(TmfTimestampFormat.getDefaulTimeFormat().format(fDataModel.getEndTime()));
+ } else {
+ fTimeRangeStartText.setText(""); //$NON-NLS-1$
+ fTimeRangeEndText.setText(""); //$NON-NLS-1$
+ }
}
// ------------------------------------------------------------------------
// PaintListener
// ------------------------------------------------------------------------
-
+ /**
+ * Image key string for the canvas.
+ */
protected final String IMAGE_KEY = "double-buffer-image"; //$NON-NLS-1$
@Override
final int canvasHeight = fCanvas.getBounds().height;
// Make sure we have something to draw upon
- if (canvasWidth <= 0 || canvasHeight <= 0)
+ if (canvasWidth <= 0 || canvasHeight <= 0) {
return;
+ }
// Retrieve image; re-create only if necessary
Image image = (Image) fCanvas.getData(IMAGE_KEY);
private void formatImage(final GC imageGC, final Image image) {
- if (fScaledData == null)
+ if (fScaledData == null) {
return;
+ }
final HistogramScaledData scaledData = new HistogramScaledData(fScaledData);
final int width = image.getBounds().width;
final int height = image.getBounds().height;
+ // Turn off anti-aliasing
+ int aliasing = imageGC.getAntialias();
+ imageGC.setAntialias(SWT.OFF);
+
// Clear the drawing area
imageGC.setBackground(fBackgroundColor);
imageGC.fillRectangle(0, 0, image.getBounds().width + 1, image.getBounds().height + 1);
// Draw the histogram bars
- imageGC.setBackground(fHistoBarColor);
final int limit = width < scaledData.fWidth ? width : scaledData.fWidth;
- for (int i = 1; i < limit; i++) {
- final int value = (int) (scaledData.fData[i] * scaledData.fScalingFactor);
- imageGC.fillRectangle(i, height - value, 1, value);
+ double factor = HistogramScaledData.hideLostEvents ? scaledData.fScalingFactor : scaledData.fScalingFactorCombined;
+ for (int i = 0; i < limit; i++) {
+ final int value = (int) Math.ceil(scaledData.fData[i] * factor);
+ int x = i + fOffset;
+
+ // in Linux, the last pixel in a line is not drawn,
+ // so draw lost events first, one pixel too far
+ if (!HistogramScaledData.hideLostEvents) {
+ imageGC.setForeground(fLostEventColor);
+ final int lostEventValue = (int) Math.ceil(scaledData.fLostEventsData[i] * factor);
+ if (lostEventValue != 0) {
+ // drawing a line is inclusive, so we should remove 1 from y2
+ // but we don't because Linux
+ imageGC.drawLine(x, height - value - lostEventValue, x, height - value);
+ }
+ }
+
+ // then draw normal events second, to overwrite that extra pixel
+ imageGC.setForeground(fHistoBarColor);
+ imageGC.drawLine(x, height - value, x, height);
+ }
+
+ // Draw the selection bars
+ int alpha = imageGC.getAlpha();
+ imageGC.setAlpha(100);
+ imageGC.setForeground(fSelectionForegroundColor);
+ imageGC.setBackground(fSelectionBackgroundColor);
+ final int beginBucket = scaledData.fSelectionBeginBucket + fOffset;
+ if (beginBucket >= 0 && beginBucket < limit) {
+ imageGC.drawLine(beginBucket, 0, beginBucket, height);
+ }
+ final int endBucket = scaledData.fSelectionEndBucket + fOffset;
+ if (endBucket >= 0 && endBucket < limit && endBucket != beginBucket) {
+ imageGC.drawLine(endBucket, 0, endBucket, height);
}
+ if (Math.abs(endBucket - beginBucket) > 1) {
+ if (endBucket > beginBucket) {
+ imageGC.fillRectangle(beginBucket + 1, 0, endBucket - beginBucket - 1, height);
+ } else {
+ imageGC.fillRectangle(endBucket + 1, 0, beginBucket - endBucket - 1, height);
+ }
+ }
+ imageGC.setAlpha(alpha);
+
+ // Add a dashed line as a delimiter
+ int delimiterIndex = (int) ((getDataModel().getEndTime() - scaledData.getFirstBucketTime()) / scaledData.fBucketDuration) + 1;
+ drawDelimiter(imageGC, fLastEventColor, height, delimiterIndex);
+
+ // Fill the area to the right of delimiter with background color
+ imageGC.setBackground(fFillColor);
+ imageGC.fillRectangle(delimiterIndex + 1, 0, width - (delimiterIndex + 1), height);
+
+ // Restore anti-aliasing
+ imageGC.setAntialias(aliasing);
- // Draw the current event bar
- final int currentBucket = scaledData.fCurrentBucket;
- if (currentBucket >= 0 && currentBucket < limit)
- drawDelimiter(imageGC, fCurrentEventColor, height, currentBucket);
-
- // Add a dashed line as a delimiter (at the right of the last bar)
- int lastEventIndex = limit - 1;
- while (lastEventIndex >= 0 && scaledData.fData[lastEventIndex] == 0)
- lastEventIndex--;
- lastEventIndex += (lastEventIndex < limit - 1) ? 1 : 0;
- drawDelimiter(imageGC, fLastEventColor, height, lastEventIndex);
} catch (final Exception e) {
// Do nothing
}
}
- private void drawDelimiter(final GC imageGC, final Color color, final int height, final int index) {
+ private static void drawDelimiter(final GC imageGC, final Color color,
+ final int height, final int index) {
imageGC.setBackground(color);
final int dash = height / 4;
imageGC.fillRectangle(index, 0 * dash, 1, dash - 1);
imageGC.fillRectangle(index, 3 * dash, 1, height - 3 * dash);
}
+ /**
+ * Draw a time range window
+ *
+ * @param imageGC
+ * the GC
+ * @param rangeStartTime
+ * the range start time
+ * @param rangeDuration
+ * the range duration
+ * @since 2.2
+ */
+ protected void drawTimeRangeWindow(GC imageGC, long rangeStartTime, long rangeDuration) {
+
+ if (fScaledData == null) {
+ return;
+ }
+
+ // Map times to histogram coordinates
+ long bucketSpan = Math.max(fScaledData.fBucketDuration, 1);
+ long startTime = Math.min(rangeStartTime, rangeStartTime + rangeDuration);
+ int rangeWidth = (int) (Math.abs(rangeDuration) / bucketSpan);
+
+ int left = (int) ((startTime - fDataModel.getFirstBucketTime()) / bucketSpan);
+ int right = left + rangeWidth;
+ int center = (left + right) / 2;
+ int height = fCanvas.getSize().y;
+ int arc = Math.min(15, rangeWidth);
+
+ // Draw the selection window
+ imageGC.setForeground(fTimeRangeColor);
+ imageGC.setLineWidth(1);
+ imageGC.setLineStyle(SWT.LINE_SOLID);
+ imageGC.drawRoundRectangle(left, 0, rangeWidth, height - 1, arc, arc);
+
+ // Fill the selection window
+ imageGC.setBackground(fTimeRangeColor);
+ imageGC.setAlpha(35);
+ imageGC.fillRoundRectangle(left + 1, 1, rangeWidth - 1, height - 2, arc, arc);
+ imageGC.setAlpha(255);
+
+ // Draw the cross hair
+ imageGC.setForeground(fTimeRangeColor);
+ imageGC.setLineWidth(1);
+ imageGC.setLineStyle(SWT.LINE_SOLID);
+
+ int chHalfWidth = ((rangeWidth < 60) ? (rangeWidth * 2) / 3 : 40) / 2;
+ imageGC.drawLine(center - chHalfWidth, height / 2, center + chHalfWidth, height / 2);
+ imageGC.drawLine(center, (height / 2) - chHalfWidth, center, (height / 2) + chHalfWidth);
+ }
+
// ------------------------------------------------------------------------
// KeyListener
// ------------------------------------------------------------------------
@Override
public void mouseDown(final MouseEvent event) {
- if (fDataModel.getNbEvents() > 0 && fScaledData.fLastBucket >= event.x) {
- fScaledData.fCurrentBucket = event.x;
- updateCurrentEventTime();
+ if (fScaledData != null && event.button == 1 && fDragState == DRAG_NONE && fDataModel.getNbEvents() != 0) {
+ fDragState = DRAG_SELECTION;
+ fDragButton = event.button;
+ if ((event.stateMask & SWT.MODIFIER_MASK) == SWT.SHIFT) {
+ if (Math.abs(event.x - fScaledData.fSelectionBeginBucket) < Math.abs(event.x - fScaledData.fSelectionEndBucket)) {
+ fScaledData.fSelectionBeginBucket = fScaledData.fSelectionEndBucket;
+ fSelectionBegin = fSelectionEnd;
+ }
+ fSelectionEnd = Math.min(getTimestamp(event.x), getEndTime());
+ fScaledData.fSelectionEndBucket = (int) ((fSelectionEnd - fScaledData.fFirstBucketTime) / fScaledData.fBucketDuration);
+ } else {
+ fSelectionBegin = Math.min(getTimestamp(event.x), getEndTime());
+ fScaledData.fSelectionBeginBucket = (int) ((fSelectionBegin - fScaledData.fFirstBucketTime) / fScaledData.fBucketDuration);
+ fSelectionEnd = fSelectionBegin;
+ fScaledData.fSelectionEndBucket = fScaledData.fSelectionBeginBucket;
+ }
+ fCanvas.redraw();
}
}
@Override
public void mouseUp(final MouseEvent event) {
+ if (fDragState == DRAG_SELECTION && event.button == fDragButton) {
+ fDragState = DRAG_NONE;
+ fDragButton = 0;
+ updateSelectionTime();
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // MouseMoveListener
+ // ------------------------------------------------------------------------
+
+ /**
+ * @since 2.2
+ */
+ @Override
+ public void mouseMove(MouseEvent event) {
+ if (fDragState == DRAG_SELECTION && fDataModel.getNbEvents() > 0) {
+ fSelectionEnd = Math.max(getStartTime(), Math.min(getEndTime(), getTimestamp(event.x)));
+ fScaledData.fSelectionEndBucket = (int) ((fSelectionEnd - fScaledData.fFirstBucketTime) / fScaledData.fBucketDuration);
+ fCanvas.redraw();
+ }
}
// ------------------------------------------------------------------------
@Override
public void mouseHover(final MouseEvent event) {
- if (fDataModel.getNbEvents() > 0 && fScaledData != null && fScaledData.fLastBucket >= event.x) {
- final String tooltip = formatToolTipLabel(event.x);
- fCanvas.setToolTipText(tooltip);
+ if (fDataModel.getNbEvents() > 0 && fScaledData != null) {
+ int delimiterIndex = (int) ((fDataModel.getEndTime() - fScaledData.getFirstBucketTime()) / fScaledData.fBucketDuration) + 1;
+ if (event.x < delimiterIndex) {
+ final String tooltip = formatToolTipLabel(event.x - fOffset);
+ fCanvas.setToolTipText(tooltip);
+ return;
+ }
}
+ fCanvas.setToolTipText(null);
}
private String formatToolTipLabel(final int index) {
- long startTime = fScaledData.getBucketStartTime(fScaledData.fCurrentBucket);
+ long startTime = fScaledData.getBucketStartTime(index);
// negative values are possible if time values came into the model in decreasing order
- if (startTime < 0)
+ if (startTime < 0) {
startTime = 0;
- final long endTime = fScaledData.getBucketEndTime(fScaledData.fCurrentBucket);
+ }
+ final long endTime = fScaledData.getBucketEndTime(index);
final int nbEvents = (index >= 0) ? fScaledData.fData[index] : 0;
-
+ final String newLine = System.getProperty("line.separator"); //$NON-NLS-1$
final StringBuffer buffer = new StringBuffer();
- buffer.append("Range = ["); //$NON-NLS-1$
- buffer.append(HistogramUtils.nanosecondsToString(startTime));
- buffer.append(","); //$NON-NLS-1$
- buffer.append(HistogramUtils.nanosecondsToString(endTime));
- buffer.append(")\n"); //$NON-NLS-1$
- buffer.append("Event count = "); //$NON-NLS-1$
- buffer.append(nbEvents);
+ int selectionBeginBucket = Math.min(fScaledData.fSelectionBeginBucket, fScaledData.fSelectionEndBucket);
+ int selectionEndBucket = Math.max(fScaledData.fSelectionBeginBucket, fScaledData.fSelectionEndBucket);
+ if (selectionBeginBucket <= index && index <= selectionEndBucket && fSelectionBegin != fSelectionEnd) {
+ TmfTimestampDelta delta = new TmfTimestampDelta(Math.abs(fSelectionEnd - fSelectionBegin), ITmfTimestamp.NANOSECOND_SCALE);
+ buffer.append(NLS.bind(Messages.Histogram_selectionSpanToolTip, delta.toString()));
+ buffer.append(newLine);
+ }
+ buffer.append(NLS.bind(Messages.Histogram_bucketRangeToolTip,
+ new TmfTimestamp(startTime, ITmfTimestamp.NANOSECOND_SCALE).toString(),
+ new TmfTimestamp(endTime, ITmfTimestamp.NANOSECOND_SCALE).toString()));
+ buffer.append(newLine);
+ buffer.append(NLS.bind(Messages.Histogram_eventCountToolTip, nbEvents));
+ if (!HistogramScaledData.hideLostEvents) {
+ final int nbLostEvents = (index >= 0) ? fScaledData.fLostEventsData[index] : 0;
+ buffer.append(newLine);
+ buffer.append(NLS.bind(Messages.Histogram_lostEventCountToolTip, nbLostEvents));
+ }
return buffer.toString();
}
public void controlResized(final ControlEvent event) {
fDataModel.complete();
}
+
+ // ------------------------------------------------------------------------
+ // Signal Handlers
+ // ------------------------------------------------------------------------
+
+ /**
+ * Format the timestamp and update the display
+ *
+ * @param signal
+ * the incoming signal
+ * @since 2.0
+ */
+ @TmfSignalHandler
+ public void timestampFormatUpdated(TmfTimestampFormatUpdateSignal signal) {
+ if (fDataModel.getNbEvents() == 0) {
+ return;
+ }
+
+ updateRangeTextControls();
+
+ fComposite.layout();
+ }
+
}
projects / deliverable / tracecompass.git / blobdiff