diff options
author | Francois Chouinard | 2011-07-22 15:49:28 +0000 |
---|---|---|
committer | Francois Chouinard | 2011-07-22 15:49:28 +0000 |
commit | 5437fc29b229d08a50b719c7ba5ed72e3e91f001 (patch) | |
tree | 54eeace1b4c80d61d8659c0fe3f283471d8d5048 /lttng/org.eclipse.linuxtools.lttng.ui/src | |
parent | dd3a8b8286575cba53fa95fff290fb708f843edd (diff) | |
download | org.eclipse.linuxtools-5437fc29b229d08a50b719c7ba5ed72e3e91f001.tar.gz org.eclipse.linuxtools-5437fc29b229d08a50b719c7ba5ed72e3e91f001.tar.xz org.eclipse.linuxtools-5437fc29b229d08a50b719c7ba5ed72e3e91f001.zip |
Refactor the Histogram View (Bug352885)
Diffstat (limited to 'lttng/org.eclipse.linuxtools.lttng.ui/src')
31 files changed, 2319 insertions, 5117 deletions
diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/LTTngUILogger.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/LTTngUILogger.java new file mode 100644 index 0000000000..e6e163f056 --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/LTTngUILogger.java @@ -0,0 +1,38 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui; + +/** + * <b><u>LTTngUILogger</u></b> + * <p> + * A logging utility + */ +public class LTTngUILogger { + + public static void logInfo(String message) { + LTTngUiPlugin.getDefault().getLogger().logInfo(message); + } + + public static void logWarning(String message) { + LTTngUiPlugin.getDefault().getLogger().logWarning(message); + } + + public static void logError(Throwable exception) { + logError("Unexpected exception", exception); //$NON-NLS-1$ + } + + public static void logError(String message, Throwable exception) { + LTTngUiPlugin.getDefault().getLogger().logError(message, exception); + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ChildrenHistogramCanvas.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ChildrenHistogramCanvas.java deleted file mode 100644 index 23ba8adff6..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ChildrenHistogramCanvas.java +++ /dev/null @@ -1,78 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-06-20 Yuriy Vashchuk - Histogram optimisations. - * 2010-07-16 Yuriy Vashchuk - Base Histogram class simplification. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.widgets.Composite; - -/** - * <b><u>ChildrenHistogramCanvas</u></b> - * <p> - * Extended implementation of the HistogramCanvas. - * <p> - * This canvas goal is to display the "SelectionWindow" in details. - */ -public class ChildrenHistogramCanvas extends HistogramCanvas { - - private HistogramCanvasPaintListener paintListener = null; - private HistogramCanvasControlListener controlListener = null; - - /** - * ChildrenHistogramCanvas constructor.<p> - * Same as HistogramCanvas, but receive a parent HistogramView that we can call from here. - * - * @param parent Composite control which will be the parent of the new instance (cannot be null) - * @param Style the style of control to construct - */ - public ChildrenHistogramCanvas(HistogramView histogramView, Composite parent, int style) { - super(histogramView, parent, style); - - // 2010-06-20 Yuriy: Moved from parent class - createAndAddPaintListener(); - createAndAddControlListener(); - } - - /* - * Create a histogram paint listener and bind it to this canvas.<p> - * - * Note : This one is a bit particular, as it is made to draw content that is of a power of 2. - * The default one draw content that is relative to the real pixels size. - */ - private void createAndAddPaintListener() { - paintListener = new HistogramCanvasPaintListener(this); - this.addPaintListener( paintListener ); - } - - /* - * Create a histogram control listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasControlListener - */ - private void createAndAddControlListener() { - controlListener = new HistogramCanvasControlListener(this); - this.addControlListener(controlListener); - } - - /** - * Notify the parent HistogramView that we have updated information.<p> - * This is intended to be called at the end of the request when we know we have up-to-date information. - */ - @Override - public void notifyParentUpdatedInformation() { - if(getHistogramView() != null) { - getHistogramView().updateSelectedWindowInformation(); - } - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/FullTraceHistogram.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/FullTraceHistogram.java new file mode 100644 index 0000000000..9cebbd4bbd --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/FullTraceHistogram.java @@ -0,0 +1,193 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.MouseEvent; +import org.eclipse.swt.events.MouseMoveListener; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; + +/** + * <b><u>FullTraceHistogram</u></b> + * <p> + * A histogram that displays the full trace. + * <p> + * It also features a selected range window that can be dragged and zoomed. + */ +public class FullTraceHistogram extends Histogram implements MouseMoveListener { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + + // Histogram colors + private final Color fTimeRangeColor = new Color(Display.getCurrent(), 255, 128, 0); + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + private final HistogramZoom fZoom; + + private long fRangeStartTime; + private long fRangeDuration; + + // ------------------------------------------------------------------------ + // Construction + // ------------------------------------------------------------------------ + + public FullTraceHistogram(HistogramView view, Composite parent) { + super(view, parent); + fZoom = new HistogramZoom(this, fCanvas, getStartTime(), getTimeLimit()); + fCanvas.addMouseMoveListener(this); + } + + @Override + public void dispose() { + fTimeRangeColor.dispose(); + super.dispose(); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + public void setTimeRange(long startTime, long duration) { + fRangeStartTime = startTime; + fRangeDuration = duration; + fZoom.setFullRange(getStartTime(), getEndTime()); + fZoom.setNewRange(fRangeStartTime, fRangeDuration); + refresh(); + } + + @Override + public void updateTimeRange(long startTime, long endTime) { + ((HistogramView) fParentView).updateTimeRange(startTime, endTime); + } + + // ------------------------------------------------------------------------ + // MouseListener + // ------------------------------------------------------------------------ + + private boolean fMouseDown; + private int fStartPosition; + + @Override + public void mouseDown(MouseEvent event) { + // Check if we are outside the time range; if so, just set the current + // event + long timestamp = getTimestamp(event.x); + if (timestamp < fZoom.getStartTime() || timestamp > fZoom.getEndTime()) { + super.mouseDown(event); + return; + } + + // Otherwise start moving the range window + fMouseDown = true; + fStartPosition = event.x; + } + + @Override + public void mouseUp(MouseEvent event) { + if (fMouseDown) { + fMouseDown = false; + ((HistogramView) fParentView).updateTimeRange(fRangeStartTime, fRangeStartTime + fZoom.getDuration()); + } + } + + // ------------------------------------------------------------------------ + // MouseMoveListener + // ------------------------------------------------------------------------ + + @Override + public void mouseMove(MouseEvent event) { + if (fMouseDown) { + int nbBuckets = event.x - fStartPosition; + long delta = nbBuckets * fScaledData.fBucketDuration; + long newStart = fZoom.getStartTime() + delta; + if (newStart < getStartTime()) + newStart = getStartTime(); + long newEnd = newStart + fZoom.getDuration(); + if (newEnd > getEndTime()) { + newEnd = getEndTime(); + newStart = newEnd - fZoom.getDuration(); + } + fRangeStartTime = newStart; + refresh(); + } + } + + // ------------------------------------------------------------------------ + // PaintListener + // ------------------------------------------------------------------------ + + @Override + public void paintControl(PaintEvent event) { + super.paintControl(event); + + Image image = (Image) fCanvas.getData(IMAGE_KEY); + assert image != null; + + Image rangeRectangleImage = new Image(image.getDevice(), image, SWT.IMAGE_COPY); + GC rangeWindowGC = new GC(rangeRectangleImage); + + if (fRangeStartTime != 0) { + drawTimeRangeWindow(rangeWindowGC, rangeRectangleImage); + } + + // Draws the buffer image onto the canvas. + event.gc.drawImage(rangeRectangleImage, 0, 0); + + rangeWindowGC.dispose(); + rangeRectangleImage.dispose(); + } + + private void drawTimeRangeWindow(GC imageGC, Image image) { + + // Map times to histogram coordinates + long bucketSpan = fScaledData.fBucketDuration; + int rangeWidth = (int) (fRangeDuration / bucketSpan); + + int left = (int) ((fRangeStartTime - fDataModel.getStartTime()) / bucketSpan); + int right = left + rangeWidth; + int center = (left + right) / 2; + int height = fCanvas.getSize().y - 2; + + // Draw the selection window + imageGC.setForeground(fTimeRangeColor); + imageGC.setLineWidth(1); + imageGC.setLineStyle(SWT.LINE_SOLID); + imageGC.drawRoundRectangle(left, 0, rangeWidth, height - 1, 15, 15); + + // Fill the selection window + imageGC.setBackground(fTimeRangeColor); + imageGC.setAlpha(35); + imageGC.fillRoundRectangle(left + 1, 1, rangeWidth - 1, height - 2, 15, 15); + 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); + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Histogram.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Histogram.java new file mode 100644 index 0000000000..fc604583c7 --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Histogram.java @@ -0,0 +1,575 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.linuxtools.tmf.ui.views.TmfView; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.ControlEvent; +import org.eclipse.swt.events.ControlListener; +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.MouseTrackListener; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.events.PaintListener; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +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.Text; + +/** + * <b><u>Histogram</u></b> + * <p> + * Re-usable histogram widget with the following features: + * <ul> + * <li>Y-axis labels displaying min/max count values + * <li>X-axis labels displaying time range + * <li>a histogram displaying the distribution of values over time (note that + * the histogram might not necessarily fill the whole canvas) + * </ul> + * The widget also has 2 'markers' to identify: + * <ul> + * <li>a red dashed line over the bar that contains the currently selected event + * <li>a dark red dashed line that delimits the right end of the histogram (if + * it doesn't fill the canvas) + * </ul> + * Clicking on the histogram will select the current event at the mouse + * location. + * <p> + * Once the histogram is selected, there is some limited keyboard support: + * <ul> + * <li>Home: go to the first histogram bar + * <li>End: go to the last histogram bar + * <li>Left: go to the previous histogram + * <li>Right: go to the next histogram bar + * </ul> + * Finally, when the mouse hovers over the histogram, a tool tip showing the + * following information about the corresponding histogram bar time range: + * <ul> + * <li>start of the time range + * <li>end of the time range + * <li>number of events in that time range + * </ul> + */ +public abstract class Histogram implements ControlListener, PaintListener, KeyListener, MouseListener, MouseTrackListener { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + + // Histogram refresh frequency + private final static int REFRESH_FREQUENCY = HistogramDataModel.DEFAULT_NUMBER_OF_BUCKETS; + + // 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 fLastEventColor = Display.getCurrent().getSystemColor(SWT.COLOR_DARK_RED); + private final Color fHistoBarColor = new Color(Display.getDefault(), 74, 112, 139); + + // Timestamp scale (nanosecond) + public static final byte TIME_SCALE = -9; + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + // Owner view + protected TmfView fParentView; + + // Histogram text fields + private Text fMaxNbEventsText; + private Text fMinNbEventsText; + private Text fTimeRangeStartText; + private Text fTimeRangeEndText; + + // Histogram drawing area + protected Canvas fCanvas; + + // Data model + protected final HistogramDataModel fDataModel; + protected HistogramScaledData fScaledData; + + protected long fCurrentEventTime = 0; + + // ------------------------------------------------------------------------ + // Construction + // ------------------------------------------------------------------------ + + public Histogram(TmfView view, Composite parent) { + fParentView = view; + + createWidget(parent); + fDataModel = new HistogramDataModel(); + clear(); + + fCanvas.addControlListener(this); + fCanvas.addPaintListener(this); + fCanvas.addKeyListener(this); + fCanvas.addMouseListener(this); + fCanvas.addMouseTrackListener(this); + } + + public void dispose() { + fHistoBarColor.dispose(); + } + + private void createWidget(Composite parent) { + + final Color labelColor = parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND); + final Font fFont = adjustFont(parent); + + final int initalWidth = 10; + + // -------------------------------------------------------------------- + // Define the histogram + // -------------------------------------------------------------------- + + GridLayout gridLayout = new GridLayout(); + gridLayout.numColumns = 3; + gridLayout.marginHeight = 0; + gridLayout.marginWidth = 0; + gridLayout.marginTop = 0; + gridLayout.horizontalSpacing = 0; + gridLayout.verticalSpacing = 0; + gridLayout.marginLeft = 0; + gridLayout.marginRight = 0; + Composite composite = new Composite(parent, SWT.FILL); + composite.setLayout(gridLayout); + + // Use all the horizontal space + GridData gridData = new GridData(); + gridData.horizontalAlignment = SWT.FILL; + gridData.verticalAlignment = SWT.FILL; + gridData.grabExcessHorizontalSpace = true; + composite.setLayoutData(gridData); + + // Y-axis max event + gridData = new GridData(); + gridData.horizontalAlignment = SWT.RIGHT; + gridData.verticalAlignment = SWT.TOP; + fMaxNbEventsText = new Text(composite, SWT.READ_ONLY | SWT.RIGHT); + fMaxNbEventsText.setFont(fFont); + fMaxNbEventsText.setBackground(labelColor); + fMaxNbEventsText.setEditable(false); + fMaxNbEventsText.setText("0"); //$NON-NLS-1$ + fMaxNbEventsText.setLayoutData(gridData); + + // Histogram itself + gridData = new GridData(); + gridData.horizontalSpan = 2; + gridData.verticalSpan = 2; + gridData.horizontalAlignment = SWT.FILL; + gridData.verticalAlignment = SWT.FILL; + gridData.grabExcessHorizontalSpace = true; + fCanvas = new Canvas(composite, SWT.BORDER | SWT.DOUBLE_BUFFERED); + fCanvas.setLayoutData(gridData); + + // Y-axis min event (always 0...) + gridData = new GridData(); + gridData.horizontalAlignment = SWT.RIGHT; + gridData.verticalAlignment = SWT.BOTTOM; + fMinNbEventsText = new Text(composite, SWT.READ_ONLY | SWT.RIGHT); + fMinNbEventsText.setFont(fFont); + fMinNbEventsText.setBackground(labelColor); + fMinNbEventsText.setEditable(false); + fMinNbEventsText.setText("0"); //$NON-NLS-1$ + fMinNbEventsText.setLayoutData(gridData); + + // Dummy cell + gridData = new GridData(initalWidth, SWT.DEFAULT); + gridData.horizontalAlignment = SWT.RIGHT; + gridData.verticalAlignment = SWT.BOTTOM; + 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); + + // Window range start time + gridData = new GridData(); + gridData.horizontalAlignment = SWT.LEFT; + gridData.verticalAlignment = SWT.BOTTOM; + 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 + gridData = new GridData(); + gridData.horizontalAlignment = SWT.RIGHT; + gridData.verticalAlignment = SWT.BOTTOM; + fTimeRangeEndText = new Text(composite, SWT.READ_ONLY); + fTimeRangeEndText.setFont(fFont); + fTimeRangeEndText.setBackground(labelColor); + fTimeRangeEndText.setText(HistogramUtils.nanosecondsToString(0)); + fTimeRangeEndText.setLayoutData(gridData); + } + + private Font adjustFont(Composite composite) { + // Reduce font size for a more pleasing rendering + int fontSizeAdjustment = -2; + Font font = composite.getFont(); + FontData fontData = font.getFontData()[0]; + return new Font(font.getDevice(), fontData.getName(), fontData.getHeight() + fontSizeAdjustment, fontData.getStyle()); + } + + // ------------------------------------------------------------------------ + // Accessors + // ------------------------------------------------------------------------ + + public long getStartTime() { + return fDataModel.getStartTime(); + } + + public long getEndTime() { + return fDataModel.getEndTime(); + } + + public long getTimeLimit() { + return fDataModel.getTimeLimit(); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + public abstract void updateTimeRange(long startTime, long endTime); + + /** + * Clear the histogram and reset the data + */ + public void clear() { + fDataModel.clear(); + fScaledData = null; + refresh(); + } + + /** + * Increase the histogram bucket corresponding to [timestamp] + * + * @param timestamp + */ + public void countEvent(long timestamp) { + fDataModel.countEvent(timestamp); + if (fDataModel.getNbEvents() % REFRESH_FREQUENCY == 0) { + refresh(); + refresh(); + } + } + + /** + * Sets the current event time and refresh the display + * + * @param timestamp + */ + public void setCurrentEvent(long timestamp) { + fCurrentEventTime = timestamp; + fDataModel.setCurrentEvent(timestamp); + refresh(); + } + + /** + * 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(int offset) { + assert offset > 0 && offset < fScaledData.fWidth; + try { + return fDataModel.getStartTime() + fScaledData.fBucketDuration * offset; + } catch (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(long timestamp) { + if (timestamp < fDataModel.getStartTime() || timestamp > fDataModel.getEndTime()) + return -1; + return (int) ((timestamp - fDataModel.getStartTime()) / fScaledData.fBucketDuration); + } + + /** + * Move the currently selected bar cursor to a non-empty bucket. + * + * @param keyCode the SWT key code + */ + protected void moveCursor(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; + } + + updateCurrentEventTime(); + } + + /** + * Refresh the histogram display + */ + protected void refresh() { + if (!fCanvas.isDisposed() && fCanvas.getDisplay() != null) { + fCanvas.getDisplay().asyncExec(new Runnable() { + @Override + public void run() { + if (!fCanvas.isDisposed()) { + // Retrieve and normalize the data + int canvasWidth = fCanvas.getBounds().width; + int canvasHeight = fCanvas.getBounds().height; + fDataModel.setCurrentEvent(fCurrentEventTime); + fScaledData = fDataModel.scaleTo(canvasWidth, canvasHeight); + // If there's no data, just get out + if (fScaledData.fData[0] == 0) + return; + // Display histogram and update X-,Y-axis labels + fCanvas.redraw(); + fTimeRangeStartText.setText(HistogramUtils.nanosecondsToString(fDataModel.getStartTime())); + fTimeRangeEndText.setText(HistogramUtils.nanosecondsToString(fDataModel.getEndTime())); + if (fDataModel.getStartTime() > 0) { + fMaxNbEventsText.setText(Long.toString(fScaledData.fMaxValue)); + } + // The Y-axis area might need to be re-sized + fMaxNbEventsText.getParent().layout(); + } + } + }); + } + } + + // ------------------------------------------------------------------------ + // Helper functions + // ------------------------------------------------------------------------ + + private void updateCurrentEventTime() { + long bucketStartTime = getTimestamp(fScaledData.fCurrentBucket); + ((HistogramView) fParentView).updateCurrentEventTime(bucketStartTime); + } + + // ------------------------------------------------------------------------ + // PaintListener + // ------------------------------------------------------------------------ + + protected final String IMAGE_KEY = "double-buffer-image"; //$NON-NLS-1$ + + @Override + public void paintControl(PaintEvent event) { + + // Get the geometry + int canvasWidth = fCanvas.getBounds().width; + int canvasHeight = fCanvas.getBounds().height; + + // Make sure we have something to draw upon + if (canvasWidth <= 0 || canvasHeight <= 0) + return; + + // Retrieve image; re-create only if necessary + Image image = (Image) fCanvas.getData(IMAGE_KEY); + if (image == null || image.getBounds().width != canvasWidth || image.getBounds().height != canvasHeight) { + image = new Image(event.display, canvasWidth, canvasHeight); + fCanvas.setData(IMAGE_KEY, image); + } + + // Draw the histogram on its canvas + GC imageGC = new GC(image); + formatImage(imageGC, image); + event.gc.drawImage(image, 0, 0); + imageGC.dispose(); + } + + private void formatImage(GC imageGC, Image image) { + + if (fScaledData == null) + return; + + HistogramScaledData scaledData = new HistogramScaledData(fScaledData); + + try { + // Get drawing boundaries + int width = image.getBounds().width; + int height = image.getBounds().height; + + // 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); + int limit = width < scaledData.fWidth ? width : scaledData.fWidth; + for (int i = 1; i < limit; i++) { + int value = (int) (scaledData.fData[i] * scaledData.fScalingFactor); + imageGC.fillRectangle(i, height - value, 1, value); + } + + // Draw the current event bar + 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 (Exception e) { + // Do nothing + } + } + + private void drawDelimiter(GC imageGC, Color color, int height, int index) { + imageGC.setBackground(color); + int dash = height / 4; + imageGC.fillRectangle(index, 0 * dash, 1, dash - 1); + imageGC.fillRectangle(index, 1 * dash, 1, dash - 1); + imageGC.fillRectangle(index, 2 * dash, 1, dash - 1); + imageGC.fillRectangle(index, 3 * dash, 1, height - 3 * dash); + } + + // ------------------------------------------------------------------------ + // KeyListener + // ------------------------------------------------------------------------ + + @Override + public void keyPressed(KeyEvent event) { + moveCursor(event.keyCode); + } + + @Override + public void keyReleased(KeyEvent event) { + } + + // ------------------------------------------------------------------------ + // MouseListener + // ------------------------------------------------------------------------ + + @Override + public void mouseDoubleClick(MouseEvent event) { + } + + @Override + public void mouseDown(MouseEvent event) { + if (fDataModel.getNbEvents() > 0 && fScaledData.fLastBucket >= event.x) { + fScaledData.fCurrentBucket = event.x; + updateCurrentEventTime(); + } + } + + @Override + public void mouseUp(MouseEvent event) { + } + + // ------------------------------------------------------------------------ + // MouseTrackListener + // ------------------------------------------------------------------------ + + @Override + public void mouseEnter(MouseEvent event) { + } + + @Override + public void mouseExit(MouseEvent event) { + } + + @Override + public void mouseHover(MouseEvent event) { + if (fDataModel.getNbEvents() > 0 && fScaledData.fLastBucket >= event.x) { + String tooltip = formatToolTipLabel(event.x); + fCanvas.setToolTipText(tooltip); + } + } + + private String formatToolTipLabel(int index) { + long startTime = fDataModel.getStartTime() + fScaledData.fCurrentBucket * fScaledData.fBucketDuration; + long endTime = startTime + fScaledData.fBucketDuration; + int nbEvents = fScaledData.fData[index]; + + 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); + return buffer.toString(); + } + + // ------------------------------------------------------------------------ + // ControlListener + // ------------------------------------------------------------------------ + + @Override + public void controlMoved(ControlEvent event) { + refresh(); + } + + @Override + public void controlResized(ControlEvent event) { + refresh(); + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvas.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvas.java deleted file mode 100644 index eaf22e08f9..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvas.java +++ /dev/null @@ -1,459 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-06-20 Yuriy Vashchuk - Histogram optimisations. - * 2010-07-16 Yuriy Vashchuk - Histogram class simplification. - * Selection Window related methods has been - * implemented in Parent Histogram. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.SWT; -import org.eclipse.swt.widgets.Canvas; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; - -/** - * <b><u>HistogramCanvas</u></b> - * <p> - * Canvas implementation aimed to draw histograms. - * <p> - * This canvas goal is to display certain "HistogramContent" onto an histogram.<p> - * Several method exist to extend it so it should suit most needs. - */ -public class HistogramCanvas extends Canvas -{ - private static HistogramView histogramView = null; - - protected AsyncCanvasRedrawer canvasRedrawer = null; - protected HistogramContent histogramContent = null; - -/* - // 2010-07-16 Yuriy: Moved to child classes. - protected HistogramCanvasPaintListener paintListener = null; - protected HistogramCanvasMouseListener mouseListener = null; - protected HistogramCanvasKeyListener keyListener = null; - protected HistogramCanvasControlListener controlListener = null; -*/ - protected HistogramCanvasFocusListener focusListener = null; - -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - protected HistogramSelectedWindow currentWindow = null; -*/ - - /** - * HistogramCanvas constructor - * - * @param parent Composite control which will be the parent of the new instance (cannot be null) - * @param Style the style of control to construct - */ - public HistogramCanvas(HistogramView histogramView, Composite parent, int style) { - super(parent, style | SWT.DOUBLE_BUFFERED); - HistogramCanvas.histogramView = histogramView; - addNeededListeners(); - -/* - // 2010-06-20 Yuriy: Moved to parent hitogram class. - // New selected window, not visible by default - createNewSelectedWindow(0L); -*/ - } - - /* - * Create the needed "event listeners" and hook them to the Canvas. - */ - - protected void addNeededListeners() { - createAndAddCanvasRedrawer(); - createAndAddFocusListener(); - -/* - // 2010-06-20 Yuriy: Moved to derived classes. - createAndAddPaintListener(); - createAndAddMouseListener(); - createAndAddKeyListener(); - createAndAddControlListener(); -*/ - } - - /* - * Create a canvas redrawer and bind it to this canvas.<p> - * - * Note : AsyncCanvasRedrawer is an internal class - * This is used to redraw the canvas from a different thread - * without^H^H^H with less danger. - */ - protected void createAndAddCanvasRedrawer() { - canvasRedrawer = new AsyncCanvasRedrawer(this); - } - - /* - * Create a histogram paint listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasPaintListener - */ -/* - // 2010-07-16 Yuriy: Moved to derived classes. - protected void createAndAddPaintListener() { - paintListener = new HistogramCanvasPaintListener(this); - this.addPaintListener( paintListener ); - } -*/ - /* - * Create a histogram mouse listener and bind it to this canvas.<p> - * Note : this mouse listener handle the mouse, the move and the wheel at once. - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasMouseListener - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class - protected void createAndAddMouseListener() { - mouseListener = new HistogramCanvasMouseListener(this); - this.addMouseListener(mouseListener); - this.addMouseMoveListener(mouseListener); - this.addMouseWheelListener(mouseListener); - } -*/ - - /* - * Create a histogram key listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasKeyListener - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class - protected void createAndAddKeyListener() { - keyListener = new HistogramCanvasKeyListener(this); - this.addKeyListener(keyListener); - } -*/ - /* - * Create a histogram focus listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasFocusListener - */ - protected void createAndAddFocusListener() { - focusListener = new HistogramCanvasFocusListener(this); - this.addFocusListener(focusListener); - } - - /* - * Create a histogram control listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasControlListener - */ -/* - // 2010-07-16 Yuriy: Moved to derived classes. - protected void createAndAddControlListener() { - controlListener = new HistogramCanvasControlListener(this); - this.addControlListener(controlListener); - } -*/ - /** - * Create a new HistogramContent for this HistogramCanvas<p> - * A new <I>empty</I> content will then be created. - * - * IMPORTANT NOTE : Canvas size, bar width and bar height need to be known at this point, as these dimension are used to create a content - * of the correct size. - * - * @param canvasSize Size of the parent canvas. - * @param widthPerBar Width of the histogram "bars" - * @param barsHeight Height of the histogram "bars" - * @param maxBarsDifferenceToAverage Factor used to "chop" bars that are too tall. Set to something big (100.0?) if not needed. - */ - public void createNewHistogramContent(int canvasSize, int widthPerBar, int barsHeight, double maxBarsDifferenceToAverage) { - histogramContent = new HistogramContent( canvasSize / widthPerBar, canvasSize, widthPerBar, barsHeight, maxBarsDifferenceToAverage); - } - - /** - * Create a new selection window of the size (time width) given.<p> - * The window initial position is at X = 0. - * The window is created hidden, it won't be draw unless it is set to visible.<p> - * - * @param windowTimeDuration Time width (in nanosecond) of the window. - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void createNewSelectedWindow(long windowTimeDuration) { - currentWindow = new HistogramSelectedWindow(histogramContent); - - currentWindow.setWindowTimeWidth(windowTimeDuration); - currentWindow.setWindowXPositionCenter(0); - } -*/ - public HistogramContent getHistogramContent() { - return histogramContent; - } - - /** - * Getter for the selection window<p> - * - * @return the current selection window - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramSelectedWindow - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public HistogramSelectedWindow getCurrentWindow() { - return currentWindow; - } -*/ - - /** - * Getter for the selection window width<p> - * - * @return Time width (in nanosecond) of the selection window. - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public long getSelectedWindowSize() { - return currentWindow.getWindowTimeWidth(); - } -*/ - - /** - * Setter for the selection window width<p> - * The window size will be ajusted if it does not respect one of these constraints : - * - The window size cannot be smaller than a single histogram content interval.<p> - * - The window size cannot be larger than twice the histogram content complete time interval.<p> - * - * @param newSelectedWindowSize New time width (in nanosecond) of the selection window. - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void setSelectedWindowSize(long newSelectedWindowSize) { - - if ( newSelectedWindowSize <= 0 ) { - newSelectedWindowSize = 1L; - } - else if ( newSelectedWindowSize > (2*histogramContent.getCompleteTimeInterval()) ) { - newSelectedWindowSize = (2*histogramContent.getCompleteTimeInterval()); - } - - currentWindow.setWindowTimeWidth(newSelectedWindowSize); - } -*/ - /** - * Method to call the "Asynchronous redrawer" for this canvas<p> - * This allow safe redraw from different threads. - * - */ - public void redrawAsynchronously() { - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( canvasRedrawer == null ) { - canvasRedrawer = new AsyncCanvasRedrawer(this); - } - - canvasRedrawer.asynchronousRedraw(); - } - - /** - * Method to call the "Asynchronous NotifyParentSelectionWindowChanged" for this canvas<p> - * This allow safe update UI objects from different threads. - * - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void notifyParentSelectionWindowChangedAsynchronously() { - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( canvasRedrawer == null ) { - canvasRedrawer = new AsyncCanvasRedrawer(this); - } - - canvasRedrawer.asynchronousNotifyParentSelectionWindowChanged(); - } -*/ - - /** - * Method to call the "Asynchronous NotifyParentUpdatedInformation" for this canvas<p> - * This allow safe redraw from different threads. - * - */ - public void notifyParentUpdatedInformationAsynchronously() { - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( canvasRedrawer == null ) { - canvasRedrawer = new AsyncCanvasRedrawer(this); - } - - canvasRedrawer.asynchronousNotifyParentUpdatedInformation(); - } - - /** - * Function that is called when the selection window is moved.<p> - * Note: Given position should be relative to the previous (centered) absolute position. - * - * <B>METHOD INTENDED TO BE EXTENDED</B> - * - * @param newRelativeXPosition New position relative to the last known absolute position. - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void moveWindow(int newRelativeXPosition) { - // Nothing : function is a place holder - } -*/ - - /** - * Function that is called when the selection window is re-centered.<p> - * Note: Given position should be absolute to the window and need to be the selection window center. - * - * <B>METHOD INTENDED TO BE EXTENDED</B> - * - * @param newRelativeXPosition New absolute position. - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void setWindowCenterPosition(int newAbsoluteXPosition) { - // Nothing : function is a place holder - } -*/ - - /** - * Function that is called when the selection window size (time width) changed by an absolute time.<p> - * Note: Given time should be in nanoseconds, positive. - * - * <B>METHOD INTENDED TO BE EXTENDED</B> - * - * @param newTime New absoulte time (in nanoseconds) to apply to the window. - */ -/* -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void resizeWindowByAbsoluteTime(long newTime) { - // Nothing : function is a place holder - } -*/ - /** - * Function that is called to tell the parent that the selection window changed.<p> - * - * <B>METHOD INTENDED TO BE EXTENDED</B> - * - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void notifyParentSelectionWindowChanged() { - // Nothing : function is a place holder - } -*/ - /** - * Function that is called to tell the parent that some information changed.<p> - * - * <B>METHOD INTENDED TO BE EXTENDED</B> - * - */ - public void notifyParentUpdatedInformation() { - // Nothing : function is a place holder - } - - /** - * Getter for View - * - * @return view instance - * - */ - public static HistogramView getHistogramView() { - return histogramView; - } - - /** - * Setter for View - * - * @param histogramView reference to object - */ - public static void setHistogramView(HistogramView histogramView) { - HistogramCanvas.histogramView = histogramView; - } -} - - -/** - * <b><u>AsyncCanvasRedrawer Inner Class</u></b> - * <p> - * Asynchronous redrawer for the HistogramCanvas - * <p> - * This class role is to call method that update the UI on asynchronously. - * This should prevent any "invalid thread access" exception when trying to update UI from a different thread. - */ -class AsyncCanvasRedrawer { - - private HistogramCanvas parentCanvas = null; - - /** - * AsyncCanvasRedrawer constructor. - * - * @param newCanvas Related histogram canvas. - */ - public AsyncCanvasRedrawer(HistogramCanvas newCanvas) { - parentCanvas = newCanvas; - } - - /** - * Function to redraw the related canvas asynchonously.<p> - * - * Basically, it just run "canvas.redraw()" in asyncExec. - * - */ - public void asynchronousRedraw() { - if ((parentCanvas != null) && (!parentCanvas.isDisposed())) { - Display display = parentCanvas.getDisplay(); - display.asyncExec(new Runnable() { - @Override - public void run() { - if ((parentCanvas != null) && (!parentCanvas.isDisposed())) { - parentCanvas.redraw(); - } - } - }); - } - } - - /** - * Function to asynchronously notify the parent of the related canvas that the window changed.<p> - * - * Basically, it just run "notifyParentSelectionWindowChanged()" in asyncExec. - * - */ -/* - // 2010-07-16 Yuriy: Moved to parent histogram class. - public void asynchronousNotifyParentSelectionWindowChanged() { - if(parentCanvas != null) { - Display display = parentCanvas.getDisplay(); - display.asyncExec(new Runnable() { - public void run() { - parentCanvas.notifyParentSelectionWindowChanged(); - } - }); - } - } -*/ - - /** - * Function to asynchonously notify the parent of the related canvas that information changed.<p> - * - * Basically, it just run "notifyParentUpdatedInformation()" in asyncExec. - * - */ - public void asynchronousNotifyParentUpdatedInformation() { - if((parentCanvas != null) && (!parentCanvas.isDisposed())) { - Display display = parentCanvas.getDisplay(); - display.asyncExec(new Runnable() { - @Override - public void run() { - if((parentCanvas != null) && (!parentCanvas.isDisposed())) { - parentCanvas.notifyParentUpdatedInformation(); - } - } - }); - } - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasControlListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasControlListener.java deleted file mode 100644 index 4da176b2b2..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasControlListener.java +++ /dev/null @@ -1,72 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009, 2010 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 - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Base class simplification - *******************************************************************************/ - -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.events.ControlEvent; -import org.eclipse.swt.events.ControlListener; - -/** - * <b><u>HistogramCanvasControlListener</u></b> - * <p> - * Implementation of a ControlListener for the need of the HistogramCanvas - * <p> - */ -public class HistogramCanvasControlListener implements ControlListener { - - private HistogramCanvas ourCanvas = null; - - /** - * HistogramCanvasControlListener default constructor - */ - public HistogramCanvasControlListener() { - } - - /** - * HistogramCanvasControlListener constructor - * - * @param newCanvas Related canvas - */ - public HistogramCanvasControlListener(HistogramCanvas newCanvas) { - ourCanvas = newCanvas; - } - - - /** - * Method called when the canvas is moved.<p> - * - * Just redraw the canvas... - * - * @param event The controle event generated by the move. - */ - @Override - public void controlMoved(ControlEvent event) { - if (ourCanvas != null) - ourCanvas.redraw(); - } - - /** - * Method called when the canvas is resized.<p> - * - * We need to tell the content that the canvas size changed - * - * @param event The control event generated by the resize. - */ - @Override - public void controlResized(ControlEvent event) { - - if ( (ourCanvas != null) && (ourCanvas.getHistogramContent() != null) ) { - // Set the new canvas size - ourCanvas.getHistogramContent().setCanvasWindowSize(ourCanvas.getSize().x); - } - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasFocusListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasFocusListener.java deleted file mode 100644 index 2451ba406c..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasFocusListener.java +++ /dev/null @@ -1,63 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Heritage corrections. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.events.FocusEvent; -import org.eclipse.swt.events.FocusListener; - -/** - * <b><u>HistogramCanvasFocusListener</u></b> - * <p> - * Implementation of a FocusListener for the need of the HistogramCanvas - * <p> - */ -public class HistogramCanvasFocusListener implements FocusListener { - - private HistogramCanvas ourCanvas = null; - - /** - * HistogramCanvasFocusListener constructor - * - * @param newCanvas Related canvas - */ - public HistogramCanvasFocusListener(HistogramCanvas newCanvas) { - ourCanvas = newCanvas; - } - - /** - * Function that is called when the canvas get focus.<p> - * - * Redraw the screen to make sure everything is sane. - * - * @param event The focus event generated. - */ - @Override - public void focusGained(FocusEvent event) { - ourCanvas.redrawAsynchronously(); - } - - /** - * Function that is called when the canvas loose focus.<p> - * - * Doesn't do anything yet... - * - * @param event The focus event generated. - */ - @Override - public void focusLost(FocusEvent event) { - // Nothing to do yet - } - -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasKeyListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasKeyListener.java deleted file mode 100644 index 4461011705..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasKeyListener.java +++ /dev/null @@ -1,97 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.KeyEvent; -import org.eclipse.swt.events.KeyListener; - -/** - * <b><u>HistogramCanvasKeyListener</u></b> - * <p> - * Implementation of a KeyListener for the need of the HistogramCanvas - * <p> - */ -public class HistogramCanvasKeyListener implements KeyListener -{ - private ParentHistogramCanvas parentCanvas = null; - private boolean isShiftPressed = false; - - /** - * HistogramCanvasKeyListener constructor - * - * @param newCanvas Related canvas - */ - public HistogramCanvasKeyListener(ParentHistogramCanvas newCanvas) { - parentCanvas = newCanvas; - } - - /** - * Function that is called when a key is pressed.<p> - * Possible actions : - * - Left arrow : move the selection window left.<p> - * - Right arrow : move the selection window right.<p> - * - Shift : turn on "fast move" mode.<p> - * - * @param event The KeyEvent generated when the key was pressed. - */ - @Override - public void keyPressed(KeyEvent event) { - switch (event.keyCode) { - case SWT.SHIFT: - isShiftPressed = true; - break; - case SWT.ARROW_LEFT: - moveWindowPosition(HistogramConstant.BASIC_DISPLACEMENT_FACTOR * -1); - break; - case SWT.ARROW_RIGHT: - moveWindowPosition(HistogramConstant.BASIC_DISPLACEMENT_FACTOR); - break; - default: - break; - } - } - - /** - * Function that is called when a key is released.<p> - * Possible actions : - * - Shift : turn off "fast move" mode. - * - * @param event The KeyEvent generated when the key was pressed. - */ - @Override - public void keyReleased(KeyEvent event) { - switch (event.keyCode) { - case SWT.SHIFT: - isShiftPressed = false; - break; - default: - break; - } - } - - /** - * Function to move the window position of a given displacemnt.<p> - * - * @param displacementFactor The basic displacement to perform (positive or negative value) - */ - public void moveWindowPosition(int displacementFactor) { - - // If we are in "fast move mode", multiply the basic displacement by a factor - if ( isShiftPressed == true ) { - displacementFactor = (int)((double)displacementFactor * HistogramConstant.FAST_DISPLACEMENT_MULTIPLE); - } - - parentCanvas.moveWindow(displacementFactor); - } - -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasMouseListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasMouseListener.java deleted file mode 100644 index d9e8ec1232..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasMouseListener.java +++ /dev/null @@ -1,284 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-06-20 Yuriy Vashchuk - Selection "red square" window optimisation. - * Null pointer exception correction. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.events.MouseEvent; -import org.eclipse.swt.events.MouseListener; -import org.eclipse.swt.events.MouseMoveListener; -import org.eclipse.swt.events.MouseWheelListener; - -/** - * <b><u>HistogramCanvasMouseListener</u></b> - * <p> - * Implementation of a MouseListener for the need of the HistogramCanvas - * <p> - */ -public class HistogramCanvasMouseListener implements MouseMoveListener, MouseListener, MouseWheelListener -{ - private DelayedMouseScroll mouseScrollListener = null; - private ParentHistogramCanvas parentCanvas = null; - private int oldWindowXPositionCenter = 0; - - private boolean isWindowMoving = false; - - /** - * HistogramCanvasMouseListener constructor - * - * @param newCanvas Related canvas - */ - public HistogramCanvasMouseListener(ParentHistogramCanvas newCanvas) { - parentCanvas = newCanvas; - } - - /** - * Function called when the mouse is moved.<p> - * If the mouse button is clicked, we will move the selection window. - * - * @param event The generated mouse event when the mouse moved. - */ - @Override - public void mouseMove(MouseEvent event) { - if ( parentCanvas.getHistogramContent() != null && isWindowMoving == true ) { - - parentCanvas.setWindowCenterPosition(event.x); - } - } - - /** - * Function called when the mouse buttons are clicked.<p> - * If the button is the first one (left button), turn on the "move window" mode - * - * @param event The generated mouse event when the mouse button was pressed. - */ - @Override - public void mouseDown(MouseEvent event) { - if ( parentCanvas.getHistogramContent() != null && event.button == 1) { - isWindowMoving = true; - - oldWindowXPositionCenter = parentCanvas.getCurrentWindow().getWindowXPositionCenter(); - parentCanvas.setWindowCenterPosition(event.x); - } - } - - /** - * Function called when the mouse buttons are released.<p> - * If the button is the first one (left button), turn off the "move window" mode - * - * @param event The generated mouse event when the mouse button was released. - */ - @Override - public void mouseUp(MouseEvent event) { - if ( parentCanvas.getHistogramContent() != null && event.button == 1) { - isWindowMoving = false; - - if( oldWindowXPositionCenter != parentCanvas.getCurrentWindow().getWindowXPositionCenter()) { - parentCanvas.notifyParentSelectionWindowChangedAsynchronously(); - } - } - } - - /** - * Function called when the mouse perform a double-click.<p> - * Don't do anything yet... - * - * @param event The generated mouse event when the mouse double-click was issued. - */ - @Override - public void mouseDoubleClick(MouseEvent event) { -// System.out.println("mouseDoubleClick"); - } - - /** - * Function called when the mouse scroll button is used.<p> - * Start a "ScrollListener" that will wait for more scroll clicks as they are asynchonous. - * After a certain delay, the parent canvas will get notified. - * - * @param event The generated mouse event when the mouse scroll was spinned. - */ - @Override - public void mouseScrolled(MouseEvent event) { - - // Start a scrollListener if none exist yet and start its thread - // Otherwise, we will just notify the one that is currenly alive... - // Badly timed event could happen while the thread is dying but we can live with loss scroll events, I believe. - if ( mouseScrollListener == null ) { - mouseScrollListener = new DelayedMouseScroll(this, HistogramConstant.FULL_WAIT_MS_TIME_BETWEEN_MOUSE_SCROLL, HistogramConstant.INTERVAL_WAIT_MS_TIME_BETWEEN_POLL ); - mouseScrollListener.start(); - } - - // *** NOTE *** - // We need to refer to the "count" to know if the scroll is done backward or forward. - // Positive count mean it is done backward (from the wall in the direction of the hand) - // Negative count mean it is done backward (from the hand in the direction of the wall) - if ( event.count > 0) { - mouseScrollListener.incrementMouseScroll(); - } - else { - mouseScrollListener.decrementMouseScroll(); - } - } - - /** - * This will calculate the correct zoom time and call the canvas to resize its selection window. - * - * @param nbMouseScroll - * @return new window timerange - */ - public long receiveMouseScrollCount(int nbMouseScroll) { - - double ajustedTime = 0; - long selectedWindowSize = parentCanvas.getSelectedWindowSize(); - - // If we received Negative scroll event, ZoomOut by ZOOM_OUT_FACTOR * the number of scroll events received. - if ( nbMouseScroll < 0 ) { - ajustedTime = (double)selectedWindowSize * HistogramConstant.ZOOM_OUT_FACTOR; - ajustedTime = ajustedTime * Math.abs(nbMouseScroll); - ajustedTime = selectedWindowSize + ajustedTime; - } - // If we received Positive scroll event, ZoomIn by ZOOM_IN_FACTOR * the number of scroll events received. - else { - if(selectedWindowSize > 2) { - ajustedTime = (double)selectedWindowSize * HistogramConstant.ZOOM_IN_FACTOR; - ajustedTime = ajustedTime * Math.abs(nbMouseScroll); - ajustedTime = selectedWindowSize - ajustedTime; - } - } - - return (long)ajustedTime; - - } - - /** - * Function that will be called at the end of the "wait time" for scroll events.<p> - * This will calculate the correct zoom time and call the canvas to resize its selection window. - * - * @param nbMouseScroll - */ - public void receiveMouseScrollCountWithNotification(int nbMouseScroll) { - - if(parentCanvas.getHistogramContent() != null) { - - mouseScrollListener = null; - - // Resize the canvas selection window - parentCanvas.resizeWindowByAbsoluteTime( receiveMouseScrollCount(nbMouseScroll) ); - } - } - - /** - * Function that will be called on mouse scroll.<p> - * This will calculate the correct zoom time and call the canvas to resize its selection window. - * - * @param nbMouseScroll - */ - public void receiveMouseScrollCountWithoutNotification(int nbMouseScroll) { - if(parentCanvas.getHistogramContent() != null) { - - // Resize the canvas selection window - parentCanvas.resizeWindowByAbsoluteTimeWithoutNotification( receiveMouseScrollCount(nbMouseScroll) ); - } - } - -} - -/** - * <b><u>DelayedMouseScroll Inner Class</u></b> - * <p> - * Asynchronous "Mouse Scroll Listener" - * <p> - * This class role is to wait for mouse scroll and count them during a certain delay.<p> - * Once the time is up, it will notify the mouse listener of the number of scroll events received.<p> - * - * Note that a new scroll event received will reset the wait timer. - */ -class DelayedMouseScroll extends Thread { - - private HistogramCanvasMouseListener mouseListener = null; - - private long waitTimeBetweenScroll = 0; - private long waitTimeBetweenCheck = 0; - - private long lastScrollTime = 0L; - private int nbScrollClick = 0; - - /** - * Constructor of the DelayedMouseScroll listener.<p> - * Object will be initialized but start() need to be called for it start listening for scroll. - * - * @param newListener The parent mouse listener - * @param newWaitFullTime The time to wait for scroll events - * @param newWaitBeforeCheck The delay between polling for scroll events - */ - public DelayedMouseScroll(HistogramCanvasMouseListener newListener, long newWaitFullTime, long newWaitBeforePoll) { - - mouseListener = newListener; - - // Get the current system time. - // This will be used to determine since how long we wait for click - lastScrollTime = System.currentTimeMillis(); - - waitTimeBetweenScroll = newWaitFullTime; - waitTimeBetweenCheck = newWaitBeforePoll; - } - - /** - * Increment the counter for the number of scroll events received.<p> - * This is intended to be called by the MouseListener. - * - * Note : A new scroll event receive will reset the wait timer. - */ - public void incrementMouseScroll() { - // Reset the wait timer - lastScrollTime = System.currentTimeMillis(); - nbScrollClick++; - mouseListener.receiveMouseScrollCountWithoutNotification(nbScrollClick); - } - - /** - * Decrement the counter for the number of scroll events received.<p> - * This is intended to be called by the MouseListener. - * - * Note : A new scroll event receive will reset the wait timer. - */ - public void decrementMouseScroll() { - // Reset the wait timer - lastScrollTime = System.currentTimeMillis(); - nbScrollClick--; - mouseListener.receiveMouseScrollCountWithoutNotification(nbScrollClick); - } - - /** - * Threaded execution method.<p> - * This is the real "wait" method that will wait for mouse scroll events.<p> - * - * The function will wake every "waitTimeBetweenCheck" to check if we exhausted the timer.<p> - * So, the "longest" we could wait after the last event is "waitTimeBetweenScroll" + "waitTimeBetweenCheck" - * - */ - @Override - public void run() { - // Check if we waited more than "waitTimeBetweenScroll" - while ( (System.currentTimeMillis() - lastScrollTime) < waitTimeBetweenScroll ) { - try { - Thread.sleep(waitTimeBetweenCheck); - } - catch (Exception e) { } - } - - // Tell the mouse listener the number of click received - mouseListener.receiveMouseScrollCountWithNotification(nbScrollClick); - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasPaintListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasPaintListener.java deleted file mode 100644 index f94ce74285..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCanvasPaintListener.java +++ /dev/null @@ -1,180 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Heritage corrections. Redraw bug correction. - * Double Buffering implementation. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.events.PaintEvent; -import org.eclipse.swt.events.PaintListener; - -import org.eclipse.swt.graphics.Color; -import org.eclipse.swt.graphics.GC; -import org.eclipse.swt.graphics.Image; - -/** - * <b><u>HistogramCanvasPaintListener</u></b> - * <p> - * Implementation of a PaintListener for the need of the HistogramCanvas - * <p> - */ -public class HistogramCanvasPaintListener implements PaintListener -{ - private static ChildrenHistogramCanvas childrenCanvas = null; - protected boolean isFinished = false; - - /** - * HistogramCanvasPaintListener default constructor - */ - public HistogramCanvasPaintListener() { - } - - /** - * HistogramCanvasPaintListener constructor - * - * @param parentCanvas Related canvas - */ - public HistogramCanvasPaintListener(ChildrenHistogramCanvas newCanvas) { - childrenCanvas = newCanvas; - } - - /** - * Function called when the canvas need to redraw.<p> - * - * @param event The generated paint event when redraw is called. - */ - private final String DATA_KEY = "double-buffer-image"; //$NON-NLS-1$ - @Override - public void paintControl(PaintEvent event) { - - if (childrenCanvas.getSize().x > 0 && childrenCanvas.getSize().y > 0) { - Image image = (Image) childrenCanvas.getData(DATA_KEY); - - // Creates new image only absolutely necessary. - if (image == null - || image.getBounds().width != childrenCanvas.getBounds().width - || image.getBounds().height != childrenCanvas.getBounds().height) { - - image = new Image( - event.display, - childrenCanvas.getBounds().width, - childrenCanvas.getBounds().height - ); - - childrenCanvas.setData(DATA_KEY, image); - } - - // Initializes the graphics context of the image. - GC imageGC = new GC(image); - - // First clear the whole canvas to have a clean section where to draw - clearDrawingSection(imageGC, image, childrenCanvas); - - // If the content is null or has rady to draw we quit the function here - if ( (childrenCanvas.getHistogramContent() != null) - && (childrenCanvas.getHistogramContent().getReadyUpToPosition() != 0) ) { - - // Call the function that draw the bars -// if (!isFinished) { - drawHistogram(imageGC, image); -// } - - // Pinpoint a position if set - if (childrenCanvas.getHistogramContent().getSelectedEventTimeInWindow() > 0 ) { - drawSelectedEventInWindow(imageGC, image); - } - - // Draws the buffer image onto the canvas. - event.gc.drawImage(image, 0, 0); - } - - imageGC.dispose(); - } - } - - /** - * Clear the drawing section of the canvas<p> - * This paint the whole background in EMPTY_BACKGROUND_COLOR, so we have something clean to draw on. - * - * @param imageGC GC content. - * @param image Image content. - * @param ourCanvas Canvas to clean. - */ - public void clearDrawingSection(GC imageGC, Image image, HistogramCanvas ourCanvas) { - // Fills background. - imageGC.setBackground(ourCanvas.getDisplay().getSystemColor(HistogramConstant.EMPTY_BACKGROUND_COLOR)); - imageGC.fillRectangle(0, 0, image.getBounds().width + 1, image.getBounds().height + 1); - } - - // *** VERIFY *** - // Is it good to put this synchronized? - // - /** - * Draw the histogram bars in the canvas.<p> - * Use existing elements in HistogramContent to draw bars on the cancas; - * the element table in content need to be populated and have consistent value. - * - * @param imageGC GC content. - * @param image image content. - */ - public synchronized void drawHistogram(GC imageGC, Image image) { - - // This will be the bottom color for all the bars that wil be draw below. - imageGC.setBackground( new Color( imageGC.getDevice(), 74, 112, 139) ); - - // *** NOTE *** - // Y Position in a canvas is REVERSED, so "0" is on top of the screen and "MAX" is on bottom. - // Not very instinctive, isn't it? - - // Draw a bar from the left (pos X=0) until the pos=(NbBars*barWidth). If space is left, it will be blanked after. - for ( int x = 0; x < childrenCanvas.getHistogramContent().getReadyUpToPosition(); x++) { - imageGC.fillRectangle( - childrenCanvas.getHistogramContent().getBarsWidth() * x, - image.getBounds().height - childrenCanvas.getHistogramContent().getElementByIndex(x).intervalHeight, - childrenCanvas.getHistogramContent().getBarsWidth(), - childrenCanvas.getHistogramContent().getElementByIndex(x).intervalHeight - ); - } - - } - - /** - * Draw a certain event selected in the window.<p> - * - * @param imageGC GC content. - * @param image image content. - */ - public synchronized void drawSelectedEventInWindow(GC imageGC, Image image) { - - final HistogramContent tmpContent = childrenCanvas.getHistogramContent(); - final int tmpBarWidth = tmpContent.getBarsWidth(); - final int position = tmpContent.getClosestXPositionFromTimestamp(tmpContent.getSelectedEventTimeInWindow()); - - // This will be the color for all the bars that will be draw below. - imageGC.setForeground(childrenCanvas.getDisplay().getSystemColor(HistogramConstant.SELECTED_EVENT_COLOR)); - imageGC.setLineWidth(HistogramConstant.SELECTION_LINE_WIDTH); - imageGC.drawLine( - tmpBarWidth * position, - 0, - tmpBarWidth * position, - image.getBounds().height - ); - } - - /** - * @param isFinished the flag value - */ - public void setIsFinished(boolean isFinished) { - this.isFinished = isFinished; - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramConstant.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramConstant.java deleted file mode 100644 index 051dcddb1a..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramConstant.java +++ /dev/null @@ -1,172 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.linuxtools.lttng.LttngConstants; -import org.eclipse.swt.SWT; -import org.eclipse.swt.graphics.GC; -import org.eclipse.swt.widgets.Composite; - -/** - * <b><u>HistogramConstant</u></b> - * <p> - * Empty interface class to hold the different constants needed by the histogram. - * <p> - */ -public abstract class HistogramConstant { - - // Constants relative to requests -// public final static int MAX_EVENTS_PER_READ = LttngConstants.DEFAULT_BLOCK_SIZE; - public final static int REDRAW_EVERY_NB_EVENTS = 20000; - public final static Boolean SKIP_EMPTY_INTERVALS_WHEN_CALCULATING_AVERAGE = true; - - - // Constant relative to the content - public final static double DEFAULT_DIFFERENCE_TO_AVERAGE = 1000.0; - - - - // Constants relative to zoom. Factors need to be a percentage ( 0 < factors < 1 ) - public final static double ZOOM_IN_FACTOR = 0.1; - public final static double ZOOM_OUT_FACTOR = 0.1; - - - // Constants relative to wait time while listening for scroll events - // "FULL" is time to wait to stop "to count" mouse scroll click events - // "INTERVAL" is time to wait between polling for scroll click events - public final static long FULL_WAIT_MS_TIME_BETWEEN_MOUSE_SCROLL = 1000L; - public final static long INTERVAL_WAIT_MS_TIME_BETWEEN_POLL = 100L; - - - // Constants relative to the displacement in the trace - // Factor represent a number of HistogramContent interval - // Multiple is the factor to multiply to basic during "fast" displacement - public final static int BASIC_DISPLACEMENT_FACTOR = 1; - public final static double FAST_DISPLACEMENT_MULTIPLE = 10.0; - - - // Constants relative to the drawing of the Histogram - // Colors for the histogram. Background should be the same as the background in use - public final static int EMPTY_BACKGROUND_COLOR = SWT.COLOR_WHITE; - public final static int SELECTED_EVENT_COLOR = SWT.COLOR_RED; - - // Dimension for the line of the "Selection Window" - public final static int MINIMUM_WINDOW_WIDTH = 3; - public final static int SELECTION_LINE_WIDTH = 1; - public final static int SELECTION_CROSSHAIR_WIDTH = 1; - - - /** - * Method to format a long representing nanosecond into a proper String.<p> - * The returned String will always be like "0.000000000", missing decimal will be added. - * - * @param nanosecTime This time to format - * - * @return The formatted string - */ - public static String formatNanoSecondsTime(long nanosecTime) { - String returnedTime = Long.toString(nanosecTime); - - // If our number has over 9 digits, just add a dot after the ninth digits - if ( returnedTime.length() > 9 ) { - returnedTime = returnedTime.substring(0, returnedTime.length() - 9 ) + "." + returnedTime.substring( returnedTime.length() - 9 ); //$NON-NLS-1$ - } - // Otherwise, patch missing decimal with 0 - else { - int curSize = returnedTime.length(); - for (int l=0; (curSize+l)< 9; l++) { - returnedTime = "0" + returnedTime; //$NON-NLS-1$ - } - returnedTime = "0." + returnedTime; //$NON-NLS-1$ - } - - return returnedTime; - } - - /** - * Convert a String representing nanoseconds into a valid long.<p> - * This can handle number like "0.5", "0.123456789" as well as plain number like "12".<p> - * - * Note : This function ALWAYS return a number, if conversion failed, 0 will be returned.<p> - * - * @param timeString The string to convert - * - * @return The converted nanoseconds time as long - */ - public static long convertStringToNanoseconds( String timeString ) { - long returnedNumber = 0L; - - try { - // Avoid simple commat/dot mistake - timeString = timeString.replace(",", "."); //$NON-NLS-1$ //$NON-NLS-2$ - - // If we have a dot, we have a decimal number to convert - int dotPosition = timeString.indexOf("."); //$NON-NLS-1$ - - // If the user begun the line with a dot, we add a zero - if ( dotPosition == 0 ) { - timeString = "0" + timeString; //$NON-NLS-1$ - dotPosition = 1; - } - - // If we found a dot, verify that we have 9 digits - if ( dotPosition != -1 ) { - int decimalNumber = (timeString.length() - dotPosition -1); - - // If we have less than 9 digits, we fill with 0 - if ( decimalNumber <= 9 ) { - StringBuffer strBuffer = new StringBuffer(timeString); - for ( int nbDec=decimalNumber; nbDec<9; nbDec++) { - strBuffer.append("0"); //$NON-NLS-1$ - } - timeString = strBuffer.toString(); - } - // We have OVER 9 digits, skip the useless part - else { - timeString = timeString.substring(dotPosition, 9); - } - } - - // Conversion into decimal seconds - double dblMaxTimerange = Double.parseDouble(timeString); - // Conversion into nanoseconds - returnedNumber = (long)(dblMaxTimerange * 1000000000.0); - } - catch (NumberFormatException e) { - System.out.println("Warning : Could not convert string into nanoseconds (convertStringToLong)"); //$NON-NLS-1$ - } - - return returnedNumber; - } - - /** - * Calculate the correcte width of a String.<p> - * Useful to set a control to its maximum size; since the size depends on characters, - * this will calculate the correct sum... should be platform independant (we hope). - * - * @param parent Parent control we will use as a reference. Could be any composite. - * @param text The Text to measure the size from - * - * @return The size calculated. - */ - public static int getTextSizeInControl(Composite parent, String text) { - GC graphicContext = new GC(parent); - int textSize = 0; - for ( int pos=0; pos<text.length(); pos++ ) { - textSize += graphicContext.getAdvanceWidth( text.charAt(pos) ); - } - // Add an extra space in case there was trailing whitespace in the message - textSize += graphicContext.getAdvanceWidth( ' ' ); - - return textSize; - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramContent.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramContent.java deleted file mode 100644 index a0fd0bb8a2..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramContent.java +++ /dev/null @@ -1,789 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Heritage correction. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - - -/** - * <b><u>HistogramContent</u></b> - * <p> - * This class hold the content that will be used to draw the Histograms. - * <p> - */ -public class HistogramContent { - - // Start and end time of the content - private long startTime = 0L; - private long endTime = 0L; - - // Some information about the content - // Most of them are required to calculate position and/or draw - // Make sure they stay consistent! - private long elementsTimeInterval = 1L; - private double heightFactor = 100.0; - private long heighestEventCount = 0L; - private int maxHeight = 0; - private int canvasWindowSize = 0; - private int barsWidth = 0; - - // This value is used to calculate at which point we should "cut" bar that are too tall. - // Default value is large enought so that no bar should be cut - private double maxDifferenceToAverage = HistogramConstant.DEFAULT_DIFFERENCE_TO_AVERAGE; - // This is a factor we might apply on the max difference to average, as example if we concatenate interval together - private double maxDifferenceFactor = 1.0; - - // By default we will only consider element up to this position - private int readyUpToPosition = 0; - - // The average number of events in the content - // Note : this IS needed to draw - private int averageNumberOfEvents = 0; - - // This is to draw the selected event of the TMF framework in another color - // Set the 0 to ignore - private long selectedEventTimeInWindow = -1L; - - // The table that hold the elements - private HistogramElement[] elementTable; - - - /** - * Default constructor for the HistogramContent. - * - * @param tableSize The size ofthe element table that will be created. - * @param newCanvasSize The full size of the canvas. Used for positionning; need to be consistent with canvas. - * @param newMaxHeight The maximum height of a bar, usually same as the height of the canvas. - */ - public HistogramContent(int tableSize, int newCanvasSize, int newBarWidth, int newMaxHeight) { - this(tableSize, newCanvasSize, newBarWidth, newMaxHeight, HistogramConstant.DEFAULT_DIFFERENCE_TO_AVERAGE); - } - - /** - * Default constructor for the HistogramContent. - * - * @param tableSize The size ofthe element table that will be created. - * @param newCanvasSize The full size of the canvas. Used for positionning; need to be consistent with canvas. - * @param newMaxHeight The maximum height of a bar, usually same as the height of the canvas. - * @param newDiffToAverage This value at which point we "cut" bar that are too tall. - */ - public HistogramContent(int tableSize, int newCanvasSize, int newBarWidth, int newMaxHeight, double newDiffToAverage) { - canvasWindowSize = newCanvasSize; - barsWidth = newBarWidth; - maxHeight = newMaxHeight; - maxDifferenceToAverage = newDiffToAverage; - - // Create a new element table from the above value - // The table will not get initialized until resetTable() is called. - createNewTable(tableSize); - } - - /** - * Create a new table to hold the content element.<p> - * Note that the table is not initialized (and so unusable) until resetTable() is called. - * - * @param newTableSize The size (number of element) of the table. - */ - public void createNewTable(int newTableSize) { - elementTable = new HistogramElement[newTableSize]; - - for ( int x=0; x<elementTable.length; x++) { - elementTable[x] = new HistogramElement(); - elementTable[x].index = x; - } - } - - /** - * Reset all HistogramContent attributes, but keep the elements table untouched.<p> - */ - public void clearContentData() { - startTime = 0L; - endTime = 0L; - - elementsTimeInterval = 1L; - heightFactor = 100.0; - heighestEventCount = 0L; - - readyUpToPosition = 0; - } - - /** - * Reset the data in the elements table.<p> - * NOTE : For this to be consistent and usuable, "startTime", "endTime" and "intervalTime" need to be set already. - */ - public void resetTable() { - for ( int x=0; x<elementTable.length; x++) { - elementTable[x].index = x; - elementTable[x].firstIntervalTimestamp = startTime + (x*elementsTimeInterval); - elementTable[x].intervalNbEvents = 0L; - elementTable[x].intervalHeight = 0; - } - } - - /** - * Reset the data in the elements table.<p> - * Start and EndTime will be used to calculate elementsTimeInterval.<p> - * - * @param newStartTime The new start time to use - * @param newEndTime The new stop time to use - */ - public void resetTable(long newStartTime, long newEndTime) { - resetTable(newStartTime, newEndTime, elementsTimeInterval); - } - - /** - * Reset the data in the elements table.<p> - * elementsTimeInterval will be set to the one give, use this for fixed interval.<p> - * - * @param newStartTime The new start time to use - * @param newEndTime The new stop time to use - * @param newTimeInterval The new time interval to use - */ - public void resetTable(long newStartTime, long newEndTime, long newTimeInterval) { - - startTime = newStartTime; - endTime = newEndTime; - recalculateElementsTimeInterval(newStartTime, newEndTime); - - for ( int x=0; x<elementTable.length; x++) { - elementTable[x].index = x; - elementTable[x].firstIntervalTimestamp = startTime + (x*elementsTimeInterval); - elementTable[x].intervalNbEvents = 0L; - elementTable[x].intervalHeight = 0; - } - } - - /** - * Clear (zeroed) the data in the elements table.<p> - * NOTE : Unlike reset, this does not recalculate the content, - * so it should be done either by hand or by calling reset table after. - */ - public void clearTable() { - for ( int x=0; x<elementTable.length; x++) { - elementTable[x].index = x; - elementTable[x].firstIntervalTimestamp = 0L; - elementTable[x].intervalNbEvents = 0L; - elementTable[x].intervalHeight = 0; - } - } - - /** - * Print all HistogramContent attributes, but the elements table. - */ - @SuppressWarnings("nls") - public void printContentInfo() { - System.out.println("startTime : " + startTime); - System.out.println("endTime : " + endTime ); - System.out.println(); - System.out.println("intervalTime : " + elementsTimeInterval); - System.out.println("heightFactor : " + heightFactor); - System.out.println("heighestEventCount : " + heighestEventCount); - System.out.println(); - System.out.println("readyUpToPosition : " + readyUpToPosition); - } - - /** - * Print the data in the elements table.<p> - */ - @SuppressWarnings("nls") - public void printTable() { - for ( int x=0; x<elementTable.length; x++) { - System.out.println("X:" + x + " -> " + elementTable[x].intervalNbEvents + ":" + elementTable[x].intervalHeight + " (" + elementTable[x].firstIntervalTimestamp + ")"); - } - } - - /** - * Getter for the timestamp of the selected event in the window.<p> - * - * @return The time of the event. - */ - public long getSelectedEventTimeInWindow() { - return selectedEventTimeInWindow; - } - - /** - * Setter for the timestamp of the selected event in the window.<p> - * - * This allow to pinpoint a certain event or position in the window. - * Set to 0 or lower to ignore. - * - * @param newPosition The new event time. - */ - public void setSelectedEventTimeInWindow(long newTime) { - this.selectedEventTimeInWindow = newTime; - } - - /** - * Get an element in the table by its index.<p> - * Null is returned if the index is out of range.<p> - * Note that you can get an element past "readyUpToPosition", the index is NOT tested against it. - * - * @param index The index of the element (0 < index < nbElement) - * - * @return The element found or null if the index is wrong. - */ - public HistogramElement getElementByIndex(int index) { - HistogramElement returnedElement = null; - - if ( (index >= 0) && (index < elementTable.length) ) { - returnedElement = elementTable[index]; - } - - return returnedElement; - } - - /** - * Return the closest element to a X position on the canvas.<p> - * Note : canvasWindowSize need to be set correctly here, otherwise unexpected element might be returned.<p> - * <p> - * NOTE : This <b>ALWAYS</b> return an element; - * If calculation lead outside the table, the first or the last element will be returned. - * - * @param position The X position we are looking at (0 < pos < canvasWidth) - * - * @return The <i>closest</i> element found. - */ - public HistogramElement getClosestElementFromXPosition(int position) { - - int index = (int)Math.round((double)elementTable.length * ((double)position / (double)canvasWindowSize) ); - - // If we are out of bound, return the closest border (first or last element) - if ( index < 0) { - index = 0; - } - else if ( index >= elementTable.length ) { - index = (elementTable.length -1); - } - - return elementTable[index]; - } - - /** - * Return the closest element's timestamp to a X position on the canvas.<p> - * Note : canvasWindowSize need to be set correctly here, otherwise unexpected timestamp might be returned.<p> - * <p> - * NOTE : This <b>ALWAYS</b> return a timestamp; - * If calculation lead outside the table, the first or the last timestamp will be returned. - * - * @param position The X position we are looking at (0 < pos < canvasWidth) - * - * @return The <i>closest</i> timestamp found. - */ - public long getClosestTimestampFromXPosition(int position) { - return getClosestElementFromXPosition(position).firstIntervalTimestamp; - } - - /** - * Return the X position (relative to the canvas) of a certain element.<p> - * Note : canvasWindowSize need to be set correctly here, otherwise unexpected element might be returned.<p> - * - * NOTE : This <b>ALWAYS</b> return an element; - * If calculation lead outside the table, the first or the last element will be returned. - * - * @param targetElement The element we are looking to find the position - * - * @return The <i>closest</i> found element. - */ - public int getXPositionFromElement(HistogramElement targetElement) { - return (int)Math.round( ((double)targetElement.index / (double)elementTable.length)*(double)canvasWindowSize ); - } - - /** - * Return the closest element to a timestamp (long) given.<p> - * Note : startTime and intervalTime need to be set correctly here, otherwise unexpected element might be returned.<p> - * <p> - * NOTE : This <b>ALWAYS</b> return an element; - * If calculation lead outside the table, the first or the last element will be returned. - * - * @param timestamp The timestamp (in nanosecond, as long) of the element we are looking for (startTime < timestamp < endTime) - * - * @return The <i>closest</i> element found. - */ - public HistogramElement getClosestElementFromTimestamp(long timestamp) { - int index = (int)Math.round( (double)(timestamp - startTime)/(double)elementsTimeInterval ); - - // If we are out of bound, return the closest border (first or last element) - if ( index < 0) { - index = 0; - } - else if ( index >= elementTable.length ) { - index = (elementTable.length -1); - } - - return elementTable[index]; - } - - /** - * Return the closest X position to a timestamp (long) given.<p> - * Note : startTime and intervalTime need to be set correctly here, otherwise unexpected position might be returned.<p> - * <p> - * NOTE : This <b>ALWAYS</b> return a position; - * If calculation lead outside the table, the first or the last position will be returned. - * - * @param timestamp The timestamp (in nanosecond, as long) of the element we are looking for (startTime < timestamp < endTime) - * - * @return The <i>closest</i> position found. - */ - public int getClosestXPositionFromTimestamp(long timestamp) { - return getXPositionFromElement(getClosestElementFromTimestamp(timestamp)); - } - - /** - * Return the closest element to an element and a time interval to this element.<p> - * The time interval can be negative or positive (before or after the element). - * - * Note : IntervalTime and StartTime need to be set correctly here, otherwise unexpected result might be returned.<p> - * - * @param targetElement The element we compare the interval with. - * @param intervalToElement Time negative or positive time interval (in nanosecond) to this element. - * - * @return The <i>closest</i> found element, or null if given data are wrong. - */ - public HistogramElement getClosestElementByElementAndTimeInterval(HistogramElement targetElement, long intervalToElement) { - - // Get the timestamp of the target element - // This should always be valid as long the table is initialized - long elementTime = targetElement.firstIntervalTimestamp; - elementTime = elementTime + intervalToElement; - - return getClosestElementFromTimestamp(elementTime); - } - - /** - * Return the closest element to an element's timestamp (as long) and a time interval to this element.<p> - * The time interval can be negative or positive (before or after the element). - * - * Note : IntervalTime and StartTime need to be set correctly here, otherwise unexpected result might be returned.<p> - * - * @param timestamp The timestamp (in nanoseconds, as long) of the element we want to compare from. - * @param intervalToElement Time negative or positive time interval (in nanosecond) to this element. - * - * @return The <i>closest</i> found element, or null if given data are wrong. - */ - public int getClosestElementByTimestampAndTimeInterval(long timestamp, long intervalToElement) { - HistogramElement targetElement = getClosestElementFromTimestamp(timestamp); - HistogramElement newElement = getClosestElementByElementAndTimeInterval(targetElement, intervalToElement); - - return getXPositionFromElement(newElement); - } - - /** - * Return the closest element to an element's position and a time interval to this element.<p> - * The time interval can be negative or positive (before or after the element). - * - * Note : IntervalTime and StartTime need to be set correctly here, otherwise unexpected result might be returned.<p> - * - * @param targetPosition The position (relative to the canvas) of the element we want to compare from. - * @param intervalToElement Time negative or positive time interval (in nanosecond) to this element. - * - * @return The <i>closest</i> found element, or null if given data are wrong. - */ - public int getXPositionByPositionAndTimeInterval(int targetPosition, long intervalToElement) { - HistogramElement targetElement = getClosestElementFromXPosition(targetPosition); - HistogramElement newElement = getClosestElementByElementAndTimeInterval(targetElement, intervalToElement); - - return getXPositionFromElement(newElement); - } - - /** - * Getter for the number of element.<p> - * The same as the value of tableSize given at construction. - * - * @return The number of element in the elements table. - */ - public int getNbElement() { - return elementTable.length; - } - - /** - * Getter for the average number of events by interval in the content.<p> - * - * Note : Might be set externally (instead of calculated internally), so consistency with the content is not guarantee. - * - * @return Average number of events we currently use in - */ - public int getAverageNumberOfEvents() { - return averageNumberOfEvents; - } - - /** - * Setter for averageNumberOfEvents.<p> - * - * Note : this is used in some drawing calculation so make sure this number make sense. - * Note : you might want to call recalculateEventHeight() if you change this. - * - * @param newAverageNumberOfEvents The new average number of events to use. - */ - public void setAverageNumberOfEvents(int newAverageNumberOfEvents) { - this.averageNumberOfEvents = newAverageNumberOfEvents; - } - - /** - * Recalculate the average number of events by time interval.<p> - * - * Note : This run over all the element so this is quite cpu intensive, use with care. - */ - public void recalculateAverageNumberOfEvents() { - - int nbInterval = 0; - int totalNbEvents = 0; - - // Go over the element up to readyUpToPosition (further position might not be ready) - for ( int x=0; x<readyUpToPosition; x++) { - // Skip the empty interval if we were asked to do so. - if ( HistogramConstant.SKIP_EMPTY_INTERVALS_WHEN_CALCULATING_AVERAGE ) { - if ( elementTable[x].intervalNbEvents > 0 ) { - nbInterval++; - } - } - else { - nbInterval++; - } - - totalNbEvents += elementTable[x].intervalNbEvents; - } - // Calculate the average here - averageNumberOfEvents = (int)Math.round((double)totalNbEvents / (double)nbInterval); - } - - /** - * Getter for the start time of the content.<p> - * - * @return The start time we currently use. - */ - public long getStartTime() { - return startTime; - } - - /** - * Setter for the start time of the content.<p> - * Note : You probably want to call "resetTable()" if you change this, otherwise data might be inconsistent. - * - * @param newStartTime the new start time - */ - public void setStartTime(long newStartTime) { - this.startTime = newStartTime; - } - - - /** - * Getter for the end time of the content.<p> - * - * @return The end time we currently use. - */ - public long getEndTime() { - return endTime; - } - - /** - * Setter for the end time of the content.<p> - * Note : You probably want to call "resetTable()" if you change this, otherwise data might be inconsistent. - * - * @param newStartTime the new end time - */ - public void setEndTime(long newEndTime) { - this.endTime = newEndTime; - } - - /** - * Getter for the complete time interval of the content.<p> - * Note : This return "endTime" minus "startTime", unlike getReadyTimeInterval() it won't check the actual time of elements. - * - * @return The complete time interval - */ - public long getCompleteTimeInterval() { - return ( endTime - startTime ); - } - - /** - * Getter for the time interval for the element between first and readyUpToPosition<p> - * Note : This return element[readyPosition].time - element[first].time , not the full interval like getCompleteTimeInterval() - * - * @return The time interval of the position that are ready. - */ - public long getReadyTimeInterval() { - return ( elementTable[readyUpToPosition].firstIntervalTimestamp - elementTable[0].firstIntervalTimestamp ); - } - - /** - * Getter for the height factor of the bar.<p> - * Note : height = "nb events in interval" * heightFactor - * - * @return Height factor currently used. - */ - public double getHeightFactor() { - return heightFactor; - } - - /** - * Recalculate the height factor of the element table.<p> - * Assume values of "maxHeight", "heighestEventCount" or "averageNumberOfEvents" are set correctly. - */ - public void recalculateHeightFactor() { - // Recalculate the new HeightFactor for the element; - // the highest bar will get "maxHeight" and other bar a fraction of it. - double diffToConsider = (maxDifferenceToAverage * maxDifferenceFactor * (double)barsWidth); - - if ( heighestEventCount > (long)(diffToConsider * (double)averageNumberOfEvents) ) { - heightFactor = (double)maxHeight/( diffToConsider * (double)averageNumberOfEvents); - } - else { - heightFactor = (double)maxHeight/(double)heighestEventCount; - } - } - - /** - * Recalculate the height of each bar in the elements table.<p> - * This assume "heightFactor" is already set correctly.<p> - * - * NOTE : if "maxHeight", "heighestEventCount" or "averageNumberOfEvents" changes, - * recalculateHeightFactor() should be recalled. - */ - public void recalculateEventHeight() { - // Recalculate the height of the bars up to "readyUpToPosition" - for ( int x=0; x<readyUpToPosition; x++) { - elementTable[x].intervalHeight = (int)Math.ceil((double)elementTable[x].intervalNbEvents * heightFactor); - } - } - - /** - * Recalculate the height of each bar in a certain interval of the elements table.<p> - * Unlike recalculateEventHeight(), this only recalculate for the given range, not the whole table. - * - */ - public void recalculateEventHeightInInterval(int startPosition, int stopPosition) { - // Basic error checking on start : should be bigger than 0 - if ( startPosition < 0 ) { - startPosition = 0; - } - - // Basic error checking on start : should be smaller than length - 1 - if ( stopPosition >= elementTable.length) { - stopPosition = (elementTable.length-1); - } - - // Recalculate the height of the bars from startPosition to stopPosition - for ( int x=startPosition; x<stopPosition; x++) { - elementTable[x].intervalHeight = (int)Math.ceil((double)elementTable[x].intervalNbEvents * heightFactor); - } - } - - /** - * Getter for the full size of the canvas.<p> - * This is used for the positionnal calculation so should be consistent with the real canvas size. - * - * @return Size of the canvas we currently use. - */ - public int getCanvasWindowSize() { - return canvasWindowSize; - } - - /** - * Set a new full size of the canvas.<p> - * This is used for the positionnal calculation so should be consistent with the real canvas size. - * - * @param newSize New canvas size; - */ - public void setCanvasWindowSize(int newSize) { - canvasWindowSize = newSize; - } - - /** - * Getter for the heighest event count recorded so far for an interval.<p> - * - * Note : Might be set externally (instead of calculated internally), so consistency with the content is not guarantee. - * - * @return Current heighestEventCount - */ - public long getHeighestEventCount() { - return heighestEventCount; - } - - /** - * Setter for setHeighestEventCount.<p> - * - * Note : this is used in some drawing calculation so make sure this number make sense. - * Note : you might want to call recalculateEventHeight() if you change this. - * - * @param newHeighestEventCount Heighest event count for a single interval. - */ - public void setHeighestEventCount(long newHeighestEventCount) { - this.heighestEventCount = newHeighestEventCount; - } - - /** - * Recalculate the heightest event count for a single time interval.<p> - * - * Note : This run over all the element so this is quite cpu intensive, use with care. - */ - public void recalculateHeighestEventCount() { - // Go over the element up to readyUpToPosition (further position might not be ready) - for ( int x=0; x<readyUpToPosition; x++) { - if ( elementTable[x].intervalNbEvents > heighestEventCount ) { - this.heighestEventCount = elementTable[x].intervalNbEvents; - } - } - } - - /** - * Getter for the max height of a bar in the content.<p> - * - * @return maximum height for a bar we currently use. - */ - public int getMaxHeight() { - return maxHeight; - } - - /** - * Setter for maxHeight.<p> - * - * Note : this is used in some drawing calculation so make sure this number make sense. - * Note : you might want to call recalculateEventHeight() if you change this. - * - * @param maxHeight The new maximum height for a bar to use. - */ - public void setMaxHeight(int maxHeight) { - this.maxHeight = maxHeight; - } - - /** - * Getter for the max difference to the average height a bar can have.<p> - * This determine at which point a bar too tall is "cut". Set a very large value (like 1000.0) to ignore. - * - * @return maximum difference to the average we currently use. - */ - public double getMaxDifferenceToAverage() { - return maxDifferenceToAverage; - } - - /** - * Setter for the max difference to the average height a bar can have.<p> - * This determine at which point a bar too tall is "cut". Set a very large value (like 1000.0) to ignore. - * - * Note : this is used in some drawing calculation so make sure this number make sense. - * Note : you might want to call recalculateEventHeight() if you change this. - * - * @param newDiffToAverage The new maximum difference to the average to use. - */ - public void setMaxDifferenceToAverage(double newDiffToAverage) { - maxDifferenceToAverage = newDiffToAverage; - } - - - /** - * Getter for a factor applied to the max difference to the average height a bar can have.<p> - * This is muliplied to maxDifferenceToAverage. Set to value 1.0 to ignore. - * - * Note : this is useful if you concatenate some intervals to gether but want the average to be consistent - * - * @return maximum difference to the average we currently use. - */ - public double getMaxDifferenceToAverageFactor() { - return maxDifferenceFactor; - } - - /** - * Setter for a factor applied to the max difference to the average height a bar can have.<p> - * - * Note : this is used in some drawing calculation so make sure this number make sense. - * Note : you might want to call recalculateEventHeight() if you change this. - * Note : setting to 0 will cause bar to have a zero size... use 1.0 to desactivate - * - * @param newFactor The new factor to use. - */ - public void setMaxDifferenceToAverageFactor(double newFactor) { - maxDifferenceFactor = newFactor; - } - - - /** - * Getter for the interval time of each interval.<p> - * This is usually "(EndTime - StartTime) / NbElement" - * - * @return Currently used interval time. - */ - public long getElementsTimeInterval() { - return elementsTimeInterval; - } - - - /** - * Setter for the interval time of each interval.<p> - * - * Note : this is used in some drawing calculation so make sure this number make sense. - * Note : you migth want to call resetTable() to to fill the element's table again if you change this. - * - * @return New interval time. - */ - public void setElementsTimeInterval(long newInterval) { - this.elementsTimeInterval = newInterval; - } - - - /** - * Calculate the correct time interval of each element from the given time.<p> - * - * @return The complete time interval - */ - public void recalculateElementsTimeInterval(long startTime, long endTime) { - long tmpInterval = (long)Math.ceil((double)(endTime - startTime)/ (double)getNbElement()); - - if ( tmpInterval <= 0 ) { - tmpInterval = 1L; - } - - this.elementsTimeInterval = tmpInterval; - } - - - /** - * Getter for readyUpToPosition.<p> - * This should tell to which point the content is filled, calculated and ready to use. - * - * @return Last position processed so far. - */ - public int getReadyUpToPosition() { - return readyUpToPosition; - } - - /** - * Setter for readyUpToPosition.<p> - * Set a new point (position) up to where the content is filled, calculated and ready to use. - * - * @param newReadyUpToPosition The new position to use. - */ - public void setReadyUpToPosition(int newReadyUpToPosition) { - this.readyUpToPosition = newReadyUpToPosition; - } - - /** - * Getter for the bar width.<p> - * This is needed by the paint listener usually. - * - * @return current bars width; - */ - public int getBarsWidth() { - return barsWidth; - } - - /** - * Setter for the bar width.<p> - * Setting this to 0 will hide all the bar in the histogram. - * - * @param newBarsWidth new bars width; - */ - public void setBarsWidth(int newBarsWidth) { - this.barsWidth = newBarsWidth; - } - -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCurrentTimeControl.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCurrentTimeControl.java new file mode 100644 index 0000000000..bbdd3f135a --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramCurrentTimeControl.java @@ -0,0 +1,51 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.widgets.Composite; + +/** + * <b><u>HistogramCurrentTimeControl</u></b> + * <p> + * This control provides a group containing a text control. + */ +public class HistogramCurrentTimeControl extends HistogramTextControl { + + // ------------------------------------------------------------------------ + // Construction + // ------------------------------------------------------------------------ + + public HistogramCurrentTimeControl(HistogramView parentView, Composite parent, int textStyle, int groupStyle) { + this(parentView, parent, textStyle, groupStyle, "", HistogramUtils.nanosecondsToString(0L)); //$NON-NLS-1$ + } + + public HistogramCurrentTimeControl(HistogramView parentView, Composite parent, int textStyle, int groupStyle, String groupValue, String textValue) { + super(parentView, parent, textStyle, groupStyle, groupValue, textValue); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + @Override + protected void updateValue() { + String stringValue = fTextValue.getText(); + long value = HistogramUtils.stringToNanoseconds(stringValue); + + if (getValue() != value) { + setValue(value); + fParentView.updateCurrentEventTime(value); + } + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramDataModel.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramDataModel.java new file mode 100644 index 0000000000..5c70e3d332 --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramDataModel.java @@ -0,0 +1,269 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import java.util.Arrays; + +import org.eclipse.linuxtools.lttng.exceptions.EventOutOfSequenceException; +import org.eclipse.linuxtools.lttng.ui.LTTngUILogger; +import org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramScaledData; + +/** + * <b><u>HistogramDataModel</u></b> + * <p> + * Histogram-independent data model with the following characteristics: + * <ul> + * <li>The <i>basetime</i> is the timestamp of the first event + * <li>There is a fixed number (<i>n</i>) of buckets of uniform duration + * (<i>d</i>) + * <li>The <i>timespan</i> of the model is thus: <i>n</i> * <i>d</i> time units + * <li>Bucket <i>i</i> holds the number of events that occurred in time range: + * [<i>basetime</i> + <i>i</i> * <i>d</i>, <i>basetime</i> + (<i>i</i> + 1) * + * <i>d</i>) + * </ul> + * Initially, the bucket durations is set to 1ns. As the events are read, they + * are tallied (using <i>countEvent()</i>) in the appropriate bucket (relative + * to the <i>basetime</i>). + * <p> + * Eventually, an event will have a timestamp that exceeds the <i>timespan</i> + * high end (determined by <i>n</i>, the number of buckets, and <i>d</i>, the + * bucket duration). At this point, the histogram needs to be compacted. This is + * done by simply merging adjacent buckets by pair, in effect doubling the + * <i>timespan</i> (<i>timespan'</i> = <i>n</i> * <i>d'</i>, where <i>d'</i> = + * 2<i>d</i>). This compaction happens as needed as the trace is read. + * <p> + * The mapping from the model to the UI is performed by the <i>scaleTo()</i> + * method. By keeping the number of buckets <i>n</i> relatively large with + * respect to to the number of pixels in the actual histogram, we should achieve + * a nice result when visualizing the histogram. + * <p> + * TODO: Add filter support for more refined event counting (e.g. by trace, + * event type, etc.) + * <p> + * TODO: Cut-off eccentric values? + * TODO: Support for going back in time? + */ +public class HistogramDataModel { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + + // The default number of buckets + public static final int DEFAULT_NUMBER_OF_BUCKETS = 16 * 1000; + +// // The ratio where an eccentric value will be truncated +// private static final int MAX_TO_AVERAGE_CUTOFF_RATIO = 5; + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + // Bucket management + private final int fNbBuckets; + private final long[] fBuckets; + private long fBucketDuration; + private long fNbEvents; + private int fLastBucket; + + // Timestamps + private long fFirstEventTime; + private long fLastEventTime; + private long fCurrentEventTime; + private long fTimeLimit; + + // ------------------------------------------------------------------------ + // Constructors + // ------------------------------------------------------------------------ + + public HistogramDataModel() { + this(DEFAULT_NUMBER_OF_BUCKETS); + } + + public HistogramDataModel(int nbBuckets) { + fNbBuckets = nbBuckets; + fBuckets = new long[nbBuckets]; + clear(); + } + + public HistogramDataModel(HistogramDataModel other) { + fNbBuckets = other.fNbBuckets; + fBuckets = Arrays.copyOf(other.fBuckets, fNbBuckets); + fBucketDuration = other.fBucketDuration; + fNbEvents = other.fNbEvents; + fLastBucket = other.fLastBucket; + fFirstEventTime = other.fFirstEventTime; + fLastEventTime = other.fLastEventTime; + fCurrentEventTime = other.fCurrentEventTime; + fTimeLimit = other.fTimeLimit; + } + + // ------------------------------------------------------------------------ + // Accessors + // ------------------------------------------------------------------------ + + public long getNbEvents() { + return fNbEvents; + } + + public int getNbBuckets() { + return fNbBuckets; + } + + public long getBucketDuration() { + return fBucketDuration; + } + + public long getStartTime() { + return fFirstEventTime; + } + + public long getEndTime() { + return fLastEventTime; + } + + public long getCurrentEventTime() { + return fCurrentEventTime; + } + + public long getTimeLimit() { + return fTimeLimit; + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + /** + * Clear the histogram model. + */ + public void clear() { + Arrays.fill(fBuckets, 0); + fNbEvents = 0; + fFirstEventTime = 0; + fLastEventTime = 0; + fCurrentEventTime = 0; + fLastBucket = 0; + fBucketDuration = 1; // 1ns + updateEndTime(); + } + + /** + * Sets the current event time + * + * @param timestamp + */ + public void setCurrentEvent(long timestamp) { + fCurrentEventTime = timestamp; + } + + /** + * Add event to the correct bucket, compacting the if needed. + * + * @param timestamp the timestamp of the event to count + */ + public void countEvent(long timestamp) { + // Set the start/end time if not already done + if (fLastBucket == 0 && fBuckets[0] == 0 && timestamp > 0) { + fFirstEventTime = timestamp; + updateEndTime(); + } + if (fLastEventTime < timestamp) { + fLastEventTime = timestamp; + } + + // Compact as needed + while (timestamp >= fTimeLimit) { + mergeBuckets(); + } + + // Validate + if (timestamp < fFirstEventTime) { + String message = "Out of order timestamp. Going back in time?"; //$NON-NLS-1$ + EventOutOfSequenceException exception = new EventOutOfSequenceException(message); + LTTngUILogger.logError(message, exception); + return; + } + + // Increment the right bucket + int index = (int) ((timestamp - fFirstEventTime) / fBucketDuration); + fBuckets[index]++; + fNbEvents++; + if (fLastBucket < index) + fLastBucket = index; + } + + /** + * Scale the model data to the width and height requested. + * + * @param width + * @param height + * @return the result array of size [width] and where the highest value + * doesn't exceed [height] + */ + public HistogramScaledData scaleTo(int width, int height) { + // Basic validation + assert width > 0 && height > 0; + + // The result structure + HistogramScaledData result = new HistogramScaledData(width, height); + + // Scale horizontally + int bucketsPerBar = fLastBucket / width + 1; + result.fBucketDuration = bucketsPerBar * fBucketDuration; + for (int i = 0; i < width; i++) { + int count = 0; + for (int j = i * bucketsPerBar; j < (i + 1) * bucketsPerBar; j++) { + if (fNbBuckets <= j) + break; + count += fBuckets[j]; + } + result.fData[i] = count; + result.fLastBucket = i; + if (result.fMaxValue < count) + result.fMaxValue = count; + } + + // Scale vertically + if (result.fMaxValue > 0) { + result.fScalingFactor = (double) height / result.fMaxValue; + } + + // Set the current event index in the scaled histogram + if (fCurrentEventTime >= fFirstEventTime && fCurrentEventTime <= fLastEventTime) + result.fCurrentBucket = (int) ((fCurrentEventTime - fFirstEventTime) / fBucketDuration) / bucketsPerBar; + else + result.fCurrentBucket = HistogramScaledData.OUT_OF_RANGE_BUCKET; + + return result; + } + + // ------------------------------------------------------------------------ + // Helper functions + // ------------------------------------------------------------------------ + + private void updateEndTime() { + fTimeLimit = fFirstEventTime + fNbBuckets * fBucketDuration; + } + + private void mergeBuckets() { + for (int i = 0; i < fNbBuckets / 2; i++) { + fBuckets[i] = fBuckets[2 * i] + fBuckets[2 * i + 1]; + } + Arrays.fill(fBuckets, fNbBuckets / 2, fNbBuckets, 0); + fBucketDuration *= 2; + updateEndTime(); + fLastBucket = fNbBuckets / 2 - 1; + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramElement.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramElement.java deleted file mode 100644 index eb907d4a9c..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramElement.java +++ /dev/null @@ -1,27 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -/** - * <b><u>HistogramElement</u></b> - * <p> - * This is used by the content to keep its data. - * It would be a struct if such a thing would exist in java. - * <p> - * Each "element" should represent a certain time interval - */ -public class HistogramElement { - public int index = 0; // Position of the element in the table (table index, obviously) - public long firstIntervalTimestamp = 0L; // The first timestamp recorded for this interval - public long intervalNbEvents = 0L; // Number of events recorded in this interval - public int intervalHeight = 0; // Height (in the canvas) of this element. Should be smaller than the canvas height. -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java index 8990950c5f..7375f99a88 100644 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2009 Ericsson + * Copyright (c) 2009, 2011 Ericsson * * All rights reserved. This program and the accompanying materials are * made available under the terms of the Eclipse Public License v1.0 which @@ -8,10 +8,10 @@ * * Contributors: * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Heritage correction. + * Yuriy Vashchuk - Heritage correction. + * Francois Chouinard - Cleanup and refactoring *******************************************************************************/ + package org.eclipse.linuxtools.lttng.ui.views.histogram; import org.eclipse.linuxtools.lttng.LttngConstants; @@ -23,246 +23,51 @@ import org.eclipse.linuxtools.tmf.request.TmfEventRequest; /** * <b><u>HistogramRequest</u></b> * <p> - * Request class, to perform a request to TMF for the histograms. - * <p> */ public class HistogramRequest extends TmfEventRequest<LttngEvent> { -/* - private HistogramContent histogramContent = null; -*/ - - private int lastInterval = 0; - private long lastRangeTime = 0L; - private long nbEventsInInterval = 0L; - - private int nbIntervalNotEmpty = 1; - private int nbEventRead = 0; - - private int lastDrawPosition = 0; - - private HistogramCanvas parentCanvas = null; - - private boolean isCompleted = false; - - /** - * Constructor for HistogramRequest.<p> - * Prepare the request in TMF and reset the histogram content. - * - * @param range Range of the request. - * @param nbRequested Nb events requested. Can be "Infinity" for all. - * @param newParentCanvas HistogramCanvas related to the request. - * @param timeInterval Time interval to consider (i.e. : 1 interval is 1 bar in the histogram) - * - * @see org.eclipse.linuxtools.tmf.request.TmfEventRequest - */ - public HistogramRequest(TmfTimeRange range, int nbRequested, HistogramCanvas newParentCanvas, long timeInterval, ITmfDataRequest.ExecutionType execType) { - super((Class<LttngEvent>)LttngEvent.class, range, nbRequested, LttngConstants.DEFAULT_BLOCK_SIZE, execType); - - setIsCompleted(false); - - // *** FIXME *** - // This does not work! The request won't be processed or the number of events returned is wrong! - // We cannot use this ! - //super((Class<LttngEvent>)dataType, range); - - parentCanvas = newParentCanvas; - - // Reset the content of the HistogramContent... the given data better be valid or this will fail. - parentCanvas.getHistogramContent().clearContentData(); - parentCanvas.getHistogramContent().resetTable(range.getStartTime().getValue(), range.getEndTime().getValue(), timeInterval); - - lastRangeTime = range.getStartTime().getValue(); - - // Notify the UI even before the request started, so we set the timestamp already. - parentCanvas.notifyParentUpdatedInformationAsynchronously(); + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + private final Histogram fHistogram; + + // ------------------------------------------------------------------------ + // Constructor + // ------------------------------------------------------------------------ + + public HistogramRequest(Histogram histogram, TmfTimeRange range, int nbEvents, ITmfDataRequest.ExecutionType execType) { + super(LttngEvent.class, range, nbEvents, LttngConstants.DEFAULT_BLOCK_SIZE, execType); + fHistogram = histogram; + } + + public HistogramRequest(Histogram histogram, TmfTimeRange range, ITmfDataRequest.ExecutionType execType) { + this(histogram, range, ALL_DATA, execType); } - - /** - * HandleData function : will be called by TMF each time a new event is receive for the request.<p> - * Calculation for the content is done here. - */ -// @Override -// public void handleData() { -// LttngEvent[] result = getData(); -// LttngEvent event = (result.length > 0) ? result[0] : null; - - @Override - public void handleData(LttngEvent event) { - super.handleData(event); - // *** FIXME *** - // *** EVIL BUG *** - // The request by timerange only does not work! (see constructor above) - // However, the request with number of events will loop until it reach its number or EOF - // We have to filter out ourself the extra useless events! - // + // ------------------------------------------------------------------------ + // TmfEventRequest + // ------------------------------------------------------------------------ + + @Override + public void handleData(LttngEvent event) { + super.handleData(event); if (event != null) { - -// Tracer.trace("Hst: " + event.getTimestamp()); - - // This check is linked to the evil fix mentionned above - if ( ( event.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) && - ( event.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) ) - { - - // Distance (in time) between this event and the last one we read - long distance = ( event.getTimestamp().getValue() - lastRangeTime ); - - // Check if we changed of interval (the distance is higher than the interval time) - if ( distance > parentCanvas.getHistogramContent().getElementsTimeInterval() ) { - - parentCanvas.getHistogramContent().getElementByIndex(lastInterval).intervalNbEvents = nbEventsInInterval; - lastRangeTime = event.getTimestamp().getValue(); - - // * NOTE * - // We can skip several interval at once, so we need to find what was our interval now - lastInterval = (int)((lastRangeTime - parentCanvas.getHistogramContent().getStartTime()) / parentCanvas.getHistogramContent().getElementsTimeInterval() ); - - // *** HACK *** - // Because of the threads, weird phenomenons seem to happen here, like a position after the - // element range because another request was issued. - // This enforce the position but may result in slightly inconsistent result (i.e. a weird misplaced bar sometime). - if ( lastInterval < 0 ) { - lastInterval = 0; - } - else if ( lastInterval >= parentCanvas.getHistogramContent().getNbElement() ) { - lastInterval = (parentCanvas.getHistogramContent().getNbElement()-1); - } - - // * NOTE * - // We save the time we have here. This mean only the FIRST time read in an interval will be saved. - parentCanvas.getHistogramContent().getElementByIndex(lastInterval).firstIntervalTimestamp = lastRangeTime; - parentCanvas.getHistogramContent().setReadyUpToPosition(lastInterval); - - nbIntervalNotEmpty++; - nbEventsInInterval = 1L; - } - // We are still in the same interval, just keep counting - else { - nbEventsInInterval++; - } - - if ( nbEventsInInterval > parentCanvas.getHistogramContent().getHeighestEventCount() ) { - parentCanvas.getHistogramContent().setHeighestEventCount(nbEventsInInterval); - } - nbEventRead++; - - // Call an asynchronous redraw every REDRAW_EVERY_NB_EVENTS events - // That way we don't need to wait until to end to have something on the screen - if ( nbEventRead % HistogramConstant.REDRAW_EVERY_NB_EVENTS == 0 ) { - redrawAsyncronously(); - } - } - } - // We got a null event! This mean we reach the end of the request. - // Save the last interval we had, so we won't miss the very last events at the end. - else { - // Save the last events - parentCanvas.getHistogramContent().getElementByIndex(lastInterval).intervalNbEvents = nbEventsInInterval; - // We reached the end of the request, so assume we fill up the content as well - parentCanvas.getHistogramContent().setReadyUpToPosition(parentCanvas.getHistogramContent().getNbElement()); - - // If the interval wasn't null, count this as a "non empty" interval - if (nbEventsInInterval > 0) { - nbIntervalNotEmpty++; - } + long timestamp = event.getTimestamp().getValue(); + fHistogram.countEvent(timestamp); } } - - /** - * Function that is called when the request completed (successful or not).<p> - * Update information and redraw the screen. - */ + @Override public void handleCompleted() { - setIsCompleted(true); - parentCanvas.notifyParentUpdatedInformationAsynchronously(); - redrawAsyncronously(); - super.handleCompleted(); -// System.out.println(System.currentTimeMillis() + ": HistogramView (" + ((getExecType() == ExecutionType.LONG) ? "long" : "short") + ") completed"); + fHistogram.refresh(); + super.handleCompleted(); } - -// /** -// * Function that is called when the request completed successfully.<p> -// */ -// @Override -// public void handleSuccess() { -// // Nothing different from completed. -// } - -// /** -// * Function that is called when the request completed in failure.<p> -// */ -// @Override -// public void handleFailure() { -// // Nothing different from cancel. -// } - - /** - * Function that is called when the request was cancelled.<p> - * Redraw and set the requestCompleted flag to true; - */ + @Override public void handleCancel() { - redrawAsyncronously(); - super.handleCancel(); - } - - /** - * Update the HistogramContent with the latest information.<p> - * This will perform some calculation that might be a bit harsh so it should'nt be called too often. - */ - public void updateEventsInfo() { - // *** Note *** - // The average number of event is calculated while skipping empty interval if asked - int averageNumberOfEvents = 0; - if ( HistogramConstant.SKIP_EMPTY_INTERVALS_WHEN_CALCULATING_AVERAGE ) { - averageNumberOfEvents = (int)Math.ceil((double)nbEventRead / (double)nbIntervalNotEmpty); - } - else { - averageNumberOfEvents = (int)Math.ceil((double)nbEventRead / (double)parentCanvas.getHistogramContent().getNbElement()); - } - - parentCanvas.getHistogramContent().setAverageNumberOfEvents(averageNumberOfEvents); - - // It is possible that the height factor didn't change; - // If not, we only need to redraw the updated section, no the whole content - // Save the actual height, recalculate the height and check if there was any changes - double previousHeightFactor = parentCanvas.getHistogramContent().getHeightFactor(); - parentCanvas.getHistogramContent().recalculateHeightFactor(); - if ( parentCanvas.getHistogramContent().getHeightFactor() != previousHeightFactor ) { - parentCanvas.getHistogramContent().recalculateEventHeight(); - } - else { - parentCanvas.getHistogramContent().recalculateEventHeightInInterval(lastDrawPosition, parentCanvas.getHistogramContent().getReadyUpToPosition()); - } - - lastDrawPosition = parentCanvas.getHistogramContent().getReadyUpToPosition(); + fHistogram.refresh(); + super.handleCancel(); } - - /** - * Perform an asynchonous redraw of the screen. - */ - public void redrawAsyncronously() { - updateEventsInfo(); - // Canvas redraw is already asynchronous - parentCanvas.redrawAsynchronously(); - } - - /** - * Getter for isCompleted variable - * @return true if the request is completed - */ - public boolean getIsCompleted() { - return isCompleted; - } - /** - * Setter for isCompleted variable - * @param isCompleted value to set the completed flag - */ - public void setIsCompleted(boolean isCompleted) { - this.isCompleted = isCompleted; - } - } diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramScaledData.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramScaledData.java new file mode 100644 index 0000000000..8260b4fb59 --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramScaledData.java @@ -0,0 +1,70 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import java.util.Arrays; + +/** + * <b><u>HistogramScaledData</u></b> + * <p> + * Convenience class/struct for scaled histogram data. + */ +public class HistogramScaledData { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + + public static final int OUT_OF_RANGE_BUCKET = -1; + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + public int fWidth; + public int fHeight; + public int[] fData; + public long fBucketDuration; + public long fMaxValue; + public int fCurrentBucket; + public int fLastBucket; + public double fScalingFactor; + + // ------------------------------------------------------------------------ + // Constructor + // ------------------------------------------------------------------------ + + public HistogramScaledData(int width, int height) { + fWidth = width; + fHeight = height; + fData = new int[width]; + Arrays.fill(fData, 0); + fBucketDuration = 1; + fMaxValue = 0; + fCurrentBucket = 0; + fLastBucket = 0; + fScalingFactor = 1; + } + + public HistogramScaledData(HistogramScaledData other) { + fWidth = other.fWidth; + fHeight = other.fHeight; + fData = Arrays.copyOf(other.fData, fWidth); + fBucketDuration = other.fBucketDuration; + fMaxValue = other.fMaxValue; + fCurrentBucket = other.fCurrentBucket; + fLastBucket = other.fLastBucket; + fScalingFactor = other.fScalingFactor; + } + +}
\ No newline at end of file diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramSelectedWindow.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramSelectedWindow.java deleted file mode 100644 index cd8abadd2b..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramSelectedWindow.java +++ /dev/null @@ -1,211 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Heritage correction and selection window - * optimisations. - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -/** - * <b><u>HistogramSelectedWindow</u></b> - * <p> - * Selection window represent the selected section of the trace in the HistogramCanvas. - * <p> - * The selected window have 3 important attributes : - * <ul> - * <li>Its central position - * <li>Its time width - * <li>Its visibility (to determine if we should draw it or not) - * </ul> - * The dimension are then deduced from the first 2 values. - * This mean the window is always a perfectly symetrical rectangle. - */ -public class HistogramSelectedWindow { - - private long timestampOfLeftPosition = 0; - private long timestampOfCenterPosition = 0; - private long timestampOfRightPosition = 0; - private long windowTimeWidth = 0L; - private int windowXPositionLeft = 0; - private int windowXPositionCenter = 0; - private int windowXPositionRight = 0; - private Boolean isSelectedWindowVisible = false; - - /** - * Default constructor for HistogramSelectedWindow.<p> - * Position and TimeWidth are set to given value. - * - * @param newTraceContent HistogramContent to read window's data from - * @param centralPosition Central X Position of the selection window in the canvas (0 to canvasWidth) - * @param newWindowWidth Time width (size) of the window. (0 or greater) - */ - public HistogramSelectedWindow(HistogramContent newTraceContent, long timestampOfLeftPosition, long newWindowWidth) { - if(newTraceContent != null) { - setWindowTimeWidth(newWindowWidth); - setTimestampOfLeftPosition(timestampOfLeftPosition); - setTimestampOfRightPosition(timestampOfLeftPosition + newWindowWidth); - setTimestampOfCenterPosition(timestampOfLeftPosition + newWindowWidth / 2); - } - } - - /** - * Getter for the window visibility.<p> - * - * @return true if the window is visible (will be draw), false otherwise - */ - public boolean getSelectedWindowVisible() { - return isSelectedWindowVisible; - } - - /** - * Setter for the window visibility.<p> - * True means the window will be draw, false that it will be hidden. - * - * @param newIsSelectedWindowVisible The visibility value - */ - public void setSelectedWindowVisible(Boolean newIsSelectedWindowVisible) { - this.isSelectedWindowVisible = newIsSelectedWindowVisible; - } - - - /** - * Getter for the window time width (size) - * - * @return Window time width (size) - */ - public long getWindowTimeWidth() { - return windowTimeWidth; - } - - /** - * Setter for the window time width (size).<p> - * Width need to be a time (in nanoseconds) that's coherent to the data we are looking at. - * - * @param newWindowTimeWidth The new time width - */ - public void setWindowTimeWidth(long newWindowTimeWidth) { - this.windowTimeWidth = newWindowTimeWidth; - } - - /** - * Getter for the timestamp of left border of the window.<p> - * Compute the timestamp from the HistogramContent data; may return 0 if the content data are wrong. - * - * @return The left timestamp of the window, or 0 if it cannot compute it. - */ - public long getTimestampOfLeftPosition() { - return timestampOfLeftPosition; - } - - /** - * Setter for the timestamp of left border of the window.<p> - * @param timestampOfLeftPosition The left timestamp of the window. - */ - public void setTimestampOfLeftPosition(long timestampOfLeftPosition) { - this.timestampOfLeftPosition = timestampOfLeftPosition; - } - - /** - * Getter for the timestamp of the center of the window.<p> - * Compute the timestamp from the HistogramContent data; may return 0 if the content data are wrong. - * - * @return The center timestamp of the window, or 0 if it cannot compute it. - */ - public long getTimestampOfCenterPosition() { - return timestampOfCenterPosition; - } - - /** - * Setter for the timestamp of center border of the window.<p> - */ - public void setTimestampOfCenterPosition(long timestampOfCenterPosition) { - this.timestampOfCenterPosition = timestampOfCenterPosition; - } - - /** - * Setter for the timestamp of center border of the window.<p> - */ - public void setTimestampOfLeftCenterRightPositions(long timestampOfCenterPosition) { - this.timestampOfLeftPosition = timestampOfCenterPosition - windowTimeWidth / 2; - this.timestampOfCenterPosition = timestampOfCenterPosition; - this.timestampOfRightPosition = timestampOfCenterPosition + windowTimeWidth / 2; - } - - /** - * Getter for the timestamp of right border of the window.<p> - * Compute the timestamp from the HistogramContent data; may return 0 if the content data are wrong. - * - * @return The right timestamp of the window, or 0 if it cannot compute it. - */ - public long getTimestampOfRightPosition() { - return timestampOfRightPosition; - } - - /** - * Setter for the timestamp of right border of the window.<p> - * @param timestampOfRightPosition The right timestamp of the window. - */ - public void setTimestampOfRightPosition(long timestampOfRightPosition) { - this.timestampOfRightPosition = timestampOfRightPosition; - } - - /** - * Getter for the coordinate of left border of the window.<p> - * - * @return The left coordinate. - */ - public int getWindowXPositionLeft() { - return windowXPositionLeft; - } - - /** - * Setter for the coordinate of left border of the window.<p> - * @param windowXPositionLeft The left coordinate of the window. - */ - public void setWindowXPositionLeft(int windowXPositionLeft) { - this.windowXPositionLeft = windowXPositionLeft; - } - - /** - * Getter for the coordinate of center border of the window.<p> - * - * @return The center coordinate. - */ - public int getWindowXPositionCenter() { - return windowXPositionCenter; - } - - /** - * Setter for the coordinate of center of the window.<p> - * @param windowXPositionCenter The center coordinate of the window. - */ - public void setWindowXPositionCenter(int windowXPositionCenter) { - this.windowXPositionCenter = windowXPositionCenter; - } - - /** - * Getter for the coordinate of right border of the window.<p> - * - * @return The right coordinate. - */ - public int getWindowXPositionRight() { - return windowXPositionRight; - } - - /** - * Setter for the coordinate of right border of the window.<p> - * @param windowXPositionRight The right coordinate of the window. - */ - public void setWindowXPositionRight(int windowXPositionRight) { - this.windowXPositionRight = windowXPositionRight; - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramTextControl.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramTextControl.java new file mode 100644 index 0000000000..009fa29f3f --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramTextControl.java @@ -0,0 +1,199 @@ +/******************************************************************************* + * Copyright (c) 2009, 2011 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: + * Wiliam Bourque - Adapted from SpinnerGroup (in TimeFrameView) + * Francois Chouinard - Cleanup and refactoring + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.SWT; +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.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Group; +import org.eclipse.swt.widgets.Text; + +/** + * <b><u>HistogramTextControl</u></b> + * <p> + * This control provides a group containing a text control. + */ +public abstract class HistogramTextControl implements FocusListener, KeyListener { + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + protected final HistogramView fParentView; + private final Composite fParent; + + // Controls + private final Group fGroup; + protected final Text fTextValue; + private long fValue; + + // ------------------------------------------------------------------------ + // Constructors + // ------------------------------------------------------------------------ + + public HistogramTextControl(HistogramView parentView, Composite parent, int textStyle, int groupStyle) { + this(parentView, parent, textStyle, groupStyle, "", HistogramUtils.nanosecondsToString(0L)); //$NON-NLS-1$ + } + + public HistogramTextControl(HistogramView parentView, Composite parent, int textStyle, int groupStyle, String groupValue, String textValue) { + + fParentView = parentView; + fParent = parent; + + // -------------------------------------------------------------------- + // Reduce font size for a more pleasing rendering + // -------------------------------------------------------------------- + + final int fontSizeAdjustment = -1; + final Font font = parent.getFont(); + final FontData fontData = font.getFontData()[0]; + final Font adjustedFont = new Font(font.getDevice(), fontData.getName(), fontData.getHeight() + fontSizeAdjustment, fontData.getStyle()); + + // -------------------------------------------------------------------- + // Pre-compute the size of the control + // -------------------------------------------------------------------- + + final String longestStringValue = "." + Long.MAX_VALUE; //$NON-NLS-1$ + final int maxChars = longestStringValue.length(); + final int textBoxSize = HistogramUtils.getTextSizeInControl(parent, longestStringValue); + + // -------------------------------------------------------------------- + // Create the group + // -------------------------------------------------------------------- + + // Re-used layout variables + GridLayout gridLayout; + GridData gridData; + + // Group control + gridLayout = new GridLayout(1, false); + gridLayout.horizontalSpacing = 0; + gridLayout.verticalSpacing = 0; + fGroup = new Group(fParent, groupStyle); + fGroup.setText(groupValue); + fGroup.setFont(adjustedFont); + fGroup.setLayout(gridLayout); + + // Group control + gridData = new GridData(SWT.LEFT, SWT.CENTER, true, false); + gridData.horizontalIndent = 0; + gridData.verticalIndent = 0; + gridData.minimumWidth = textBoxSize; + fTextValue = new Text(fGroup, textStyle); + fTextValue.setTextLimit(maxChars); + fTextValue.setText(textValue); + fTextValue.setFont(adjustedFont); + fTextValue.setLayoutData(gridData); + + // -------------------------------------------------------------------- + // Add listeners + // -------------------------------------------------------------------- + + fTextValue.addFocusListener(this); + fTextValue.addKeyListener(this); + } + + // ------------------------------------------------------------------------ + // Accessors + // ------------------------------------------------------------------------ + + // State + public boolean isDisposed() { + return fGroup.isDisposed(); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + protected abstract void updateValue(); + + // LayoutData + public void setLayoutData(GridData layoutData) { + fGroup.setLayoutData(layoutData); + } + + // Time value + public void setValue(String timeString) { + long timeValue = HistogramUtils.stringToNanoseconds(timeString); + setValue(timeValue); + } + + public void setValue(final long time) { + // If this is the UI thread, process now + Display display = Display.getCurrent(); + if (display != null) { + fValue = time; + fTextValue.setText(HistogramUtils.nanosecondsToString(time)); + return; + } + + // Call "recursively" from the UI thread + if (!isDisposed()) { + Display.getDefault().asyncExec(new Runnable() { + @Override + public void run() { + if (!isDisposed()) { + setValue(time); + } + } + }); + } + } + + public long getValue() { + return fValue; + } + + // ------------------------------------------------------------------------ + // FocusListener + // ------------------------------------------------------------------------ + + @Override + public void focusGained(FocusEvent event) { + } + + @Override + public void focusLost(FocusEvent event) { + updateValue(); + } + + // ------------------------------------------------------------------------ + // KeyListener + // ------------------------------------------------------------------------ + + @Override + public void keyPressed(KeyEvent event) { + switch (event.keyCode) { + case SWT.CR: + updateValue(); + break; + default: + break; + } + } + + @Override + public void keyReleased(KeyEvent e) { + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramTimeRangeControl.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramTimeRangeControl.java new file mode 100644 index 0000000000..b12c25df88 --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramTimeRangeControl.java @@ -0,0 +1,50 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.widgets.Composite; + +/** + * <b><u>HistogramTimeRangeControl</u></b> + * <p> + * This control provides a group containing a text control. + */ +public class HistogramTimeRangeControl extends HistogramTextControl { + + // ------------------------------------------------------------------------ + // Construction + // ------------------------------------------------------------------------ + + public HistogramTimeRangeControl(HistogramView parentView, Composite parent, int textStyle, int groupStyle) { + this(parentView, parent, textStyle, groupStyle, "", HistogramUtils.nanosecondsToString(0L)); //$NON-NLS-1$ + } + + public HistogramTimeRangeControl(HistogramView parentView, Composite parent, int textStyle, int groupStyle, String groupValue, String textValue) { + super(parentView, parent, textStyle, groupStyle, groupValue, textValue); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + @Override + protected void updateValue() { + String stringValue = fTextValue.getText(); + long value = HistogramUtils.stringToNanoseconds(stringValue); + + if (getValue() != value) { + fParentView.updateTimeRange(value); + } + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramUtils.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramUtils.java new file mode 100644 index 0000000000..a5b9d53dea --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramUtils.java @@ -0,0 +1,126 @@ +/******************************************************************************* + * Copyright (c) 2009, 2011 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: + * William Bourque - Initial API and implementation + * Francois Chouinard - Cleanup and refactoring + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.widgets.Composite; + +/** + * <b><u>HistogramUtils</u></b> + * <p> + * Bunch of conversion utilities. + * <p> + */ +public abstract class HistogramUtils { + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + /** + * Format a long representing nanoseconds into a string of the form + * "[seconds].[nanoseconds]" with the appropriate zero-padding. + * <p> + * + * @param ns the timestamp in nanoseconds + * @return the formatted string + */ + public static String nanosecondsToString(long ns) { + ns = Math.abs(ns); + String time = Long.toString(ns); + + int length = time.length(); + if (time.length() > 9) { + // Just insert the decimal dot + time = time.substring(0, length - 9) + "." + time.substring(length - 9); //$NON-NLS-1$ + return time; + } + + // Zero-pad the value + for (int i = length; i < 9; i++) { + time = "0" + time; //$NON-NLS-1$ + } + time = "0." + time; //$NON-NLS-1$ + return time; + } + + /** + * Convert a string representing a time to the corresponding long. + * <p> + * + * @param time the string to convert + * @return the corresponding nanoseconds value + */ + public static long stringToNanoseconds(String time) { + + long result = 0L; + StringBuffer buffer = new StringBuffer(time); + + try { + int dot = buffer.indexOf("."); //$NON-NLS-1$ + + // Prepend a "." if none was found (assume ns) + if (dot == -1) { + buffer.insert(0, "."); //$NON-NLS-1$ + dot = 0; + } + + // Zero-pad the string for nanoseconds + for (int i = buffer.length() - dot - 1; i < 9; i++) + buffer.append("0"); //$NON-NLS-1$ + + // Remove the extra decimals if present + int nbDecimals = buffer.substring(dot + 1).length(); + if (nbDecimals > 9) + buffer.delete(buffer.substring(0, dot + 1 + 9).length(), buffer.length()); + + // Do the conversion + long seconds = (dot > 0) ? Long.parseLong(buffer.substring(0, dot)) : 0; + seconds = Math.abs(seconds); + long nanosecs = Long.parseLong(buffer.substring(dot + 1)); + result = seconds * 1000000000 + nanosecs; + + } catch (NumberFormatException e) { + // TODO: Find something interesting to say + } + + return result; + } + + /** + * Calculate the width of a String. + * <p> + * + * @param parent The control used as reference + * @param text The Text to measure + * + * @return The result size + */ + public static int getTextSizeInControl(Composite parent, String text) { + + GC controlGC = new GC(parent); + + int textSize = 0; + for (int pos = 0; pos < text.length(); pos++) { + textSize += controlGC.getAdvanceWidth(text.charAt(pos)); + } + // Add an extra space + textSize += controlGC.getAdvanceWidth(' '); + + controlGC.dispose(); + + return textSize; + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramView.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramView.java index 7d30f4c832..9bbb86f348 100644 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramView.java +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramView.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2009 Ericsson + * Copyright (c) 2009, 2010, 2011 Ericsson * * All rights reserved. This program and the accompanying materials are * made available under the terms of the Eclipse Public License v1.0 which @@ -8,1146 +8,431 @@ * * Contributors: * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-06-10 Yuriy Vashchuk - GUI reorganisation, simplification and some - * related code improvements. - * 2010-06-20 Yuriy Vashchuk - Histograms optimisation. - * 2010-07-16 Yuriy Vashchuk - Histogram Canvas Heritage correction + * Yuriy Vashchuk - GUI reorganisation, simplification and some related code improvements. + * Yuriy Vashchuk - Histograms optimisation. + * Yuriy Vashchuk - Histogram Canvas Heritage correction + * Francois Chouinard - Cleanup and refactoring *******************************************************************************/ package org.eclipse.linuxtools.lttng.ui.views.histogram; import org.eclipse.linuxtools.lttng.event.LttngEvent; -import org.eclipse.linuxtools.lttng.event.LttngTimestamp; import org.eclipse.linuxtools.tmf.event.TmfTimeRange; import org.eclipse.linuxtools.tmf.event.TmfTimestamp; import org.eclipse.linuxtools.tmf.experiment.TmfExperiment; -import org.eclipse.linuxtools.tmf.request.ITmfDataRequest; import org.eclipse.linuxtools.tmf.request.ITmfDataRequest.ExecutionType; import org.eclipse.linuxtools.tmf.signal.TmfExperimentSelectedSignal; import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal; import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler; +import org.eclipse.linuxtools.tmf.signal.TmfSignalManager; import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal; import org.eclipse.linuxtools.tmf.trace.ITmfTrace; import org.eclipse.linuxtools.tmf.ui.views.TmfView; import org.eclipse.swt.SWT; -import org.eclipse.swt.events.ControlEvent; -import org.eclipse.swt.events.ControlListener; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Text; /** * <b><u>HistogramView</u></b> * <p> - * View that contain an visual approach to the window that control the request. - * This is intended to replace the TimeFrameView + * The purpose of this view is to provide graphical time distribution statistics + * about the experiment/trace events. * <p> - * This view is composed of 2 canvas, one for the whole experiment and one for the selected window in the experiment. - * It also contain a certain number of controls to print or change informations about the experiment. + * The view is composed of two histograms and two controls: + * <ul> + * <li>an event distribution histogram for the whole experiment; + * <li>an event distribution histogram for current time window (window span); + * <li>the timestamp of the currently selected event; + * <li>the window span (size of the time window of the smaller histogram). + * </ul> + * The histograms x-axis show their respective time range. */ -public class HistogramView extends TmfView implements ControlListener { - - // *** TODO *** - // Here is what's left to do in this view - // - // 1- Make sure the interval time is small enough on very big trace (bug 311930) - // The interval time of the content is dynamically assigned from the screen width and trace duration. - // However, on very big trace (more than 1 hour), we could end up with time interval that are > 1 seconds, - // which is not very precise. - // An algorithm need to be implemented to make sure we "increase" the number of interval in the content if - // their precision is getting too bad. - // - // 2- Make sure all control are thread safe (bug 309348) - // Right now, all the basic controls (i.e. Text and Label) are sensible to "Thread Access Exception" if - // updated from different threads; we need to carefully decide when/where to redraw them. - // This is a real problem since there is a lot of thread going on in this view. - // All basic control should be subclassed to offer "Asynchronous" functions. - // - // 3- Implement a "preferences view" for the HistogramView (bug 311935) - // There is a lot of adjustable preferences in the view, however there is no way to adjust them right now - // at run time. There should be a view of some kind of "menu" to allow the user to change them while executing. - // Most of the pertinent values are in HistogramConstant.java or in this file. - +public class HistogramView extends TmfView { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + + // The view ID as defined in plugin.xml public static final String ID = "org.eclipse.linuxtools.lttng.ui.views.histogram"; //$NON-NLS-1$ - - // "Minimum" screen width size. On smaller screen, we will apply several space saving technique - private static final int SCREEN_SMALL_IF_SMALLER_THAN = 1600; - -/* - // 2010-06-20 Yuriy: We will use the dynamic height. - // Size of the "full trace" canvas - private static final int FULL_TRACE_CANVAS_HEIGHT = 25; -*/ - private static final int FULL_TRACE_BAR_WIDTH = 1; - private static final double FULL_TRACE_DIFFERENCE_TO_AVERAGE = 1.5; - - // Size of the "Selected Window" canvas -/* - // 2010-06-20 Yuriy - private static final int SELECTED_WINDOW_CANVAS_WIDTH = 300; - private static final int SMALL_SELECTED_WINDOW_CANVAS_WIDTH = 200; - private static final int SELECTED_WINDOW_CANVAS_HEIGHT = 60; -*/ - private static final int SELECTED_WINDOW_BAR_WIDTH = 1; - private static final double SELECTED_WINDOW_DIFFERENCE_TO_AVERAGE = 10.0; - - // For the two "events" label (Max and Min number of events in the selection), we force a width - // This will prevent the control from moving horizontally if the number of events in the selection varies - private static final int NB_EVENTS_FIXED_WIDTH = 50; - - // The "small font" height used to display time will be "default font" minus this constant - private static final int SMALL_FONT_MODIFIER = 2; - private static final int VERY_SMALL_FONT_MODIFIER = 4; - - // *** TODO *** - // This need to be changed as soon the framework implement a "window" -// private static long DEFAULT_WINDOW_SIZE = (10L * 100 * 1000 * 1000); // 1sec - private static long DEFAULT_WINDOW_SIZE = (1L * 100 * 1000 * 1000); // .1sec - - // The last experiment received/used by the view - private TmfExperiment<LttngEvent> lastUsedExperiment = null; - - // Parent of the view - private Composite parent = null; - - // Request and canvas for the "full trace" part - private HistogramRequest dataBackgroundFullRequest = null; - private static ParentHistogramCanvas fullExperimentCanvas = null; - - // Request and canvas for the "selected window" - private HistogramRequest selectedWindowRequest = null; - private static ChildrenHistogramCanvas selectedWindowCanvas = null; - - // Content of the timeTextGroup - // Since the user can modify them with erroneous value, - // we will keep track of the value internally - private long currentEventTime = 0L; - - // *** All the UI control below - // - // NOTE : All textboxes will be READ_ONLY. - // So the user will be able to select/copy the value in them but not to change it - private Text txtExperimentStartTime = null; - private Text txtExperimentStopTime = null; - - private Text txtWindowStartTime = null; - private Text txtWindowStopTime = null; - private Text txtWindowMaxNbEvents = null; - private Text txtWindowMinNbEvents = null; - - // We move the time label to header from TimeTextGroup.java - private static final String WINDOW_TIMESPAN_LABEL_TEXT = Messages.HistogramView_windowSpanLabel; - private static final String WINDOW_CENTER_TIME_LABEL_TEXT = Messages.HistogramView_windowCenterLabel; - private static final String CURRENT_EVENT_TIME_LABEL_TEXT = Messages.HistogramView_currentEventLabel; - private TimeTextGroup ntgWindowTimeSpan = null; - private TimeTextGroup ntgWindowCenterTime = null; - private TimeTextGroup ntgCurrentEventTime = null; - - /** - * Default constructor of the view - */ - public HistogramView() { - super(ID); - } - - /** - * Create the UI controls of this view - * - * @param parent The composite parent of this view - */ - @Override - public void createPartControl(Composite newParent) { - // Save the parent - parent = newParent; - - // Default font - Font font = parent.getFont(); - FontData tmpFontData = font.getFontData()[0]; - - - Font smallFont = null; - int nbEventWidth = -1; - int selectedCanvasWidth = -1; - boolean doesTimeTextGroupNeedAdjustment = false; - - // Calculate if we need "small screen" fixes - if ( parent.getDisplay().getBounds().width < SCREEN_SMALL_IF_SMALLER_THAN ) { - - // A lot smaller font for timestamp - smallFont = new Font(font.getDevice(), tmpFontData.getName(), tmpFontData.getHeight() - VERY_SMALL_FONT_MODIFIER, tmpFontData.getStyle()); - -/* - // 2010-06-20 Yuriy - // Smaller selection window canvas - selectedCanvasWidth = SMALL_SELECTED_WINDOW_CANVAS_WIDTH; -*/ - // Smaller event number text field - nbEventWidth = NB_EVENTS_FIXED_WIDTH/2; - - // Tell the text group to ajust - doesTimeTextGroupNeedAdjustment = true; - - } else { - - // Slightly smaller font for timestamp - smallFont = new Font(font.getDevice(), tmpFontData.getName(), tmpFontData.getHeight() - SMALL_FONT_MODIFIER, tmpFontData.getStyle()); - // Usual size for selected window and event number text field - nbEventWidth = NB_EVENTS_FIXED_WIDTH; -/* - // 2010-06-20 Yuriy - selectedCanvasWidth = SELECTED_WINDOW_CANVAS_WIDTH; -*/ - // No ajustement needed by the text group - doesTimeTextGroupNeedAdjustment = false; - - } - - - ///////////////////////////////////////////////////////////////////////////////////// - // Layout for the whole view, other elements will be in a child composite of this one - // Contains : - // Composite layoutSelectionWindow - // Composite layoutTimesSpinner - // Composite layoutExperimentHistogram - ///////////////////////////////////////////////////////////////////////////////////// - Composite layoutFullView = new Composite(parent, SWT.FILL); - GridLayout gridFullView = new GridLayout(); - gridFullView.numColumns = 2; - gridFullView.horizontalSpacing = 0; - gridFullView.verticalSpacing = 0; - gridFullView.marginHeight = 0; - gridFullView.marginWidth = 0; - layoutFullView.setLayout(gridFullView); - - - ///////////////////////////////////////////////////////////////////////////////////// - // Layout that contain the time spinners - // Contains : - // NanosecTextGroup ntgCurrentEventTime - // NanosecTextGroup ntgTimeRangeWindow - // NanosecTextGroup ntgCurrentWindowTime - ///////////////////////////////////////////////////////////////////////////////////// - Composite layoutTimeSpinners = new Composite(layoutFullView, SWT.NONE); - GridLayout gridTimesSpinner = new GridLayout(); - gridTimesSpinner.numColumns = 3; - gridTimesSpinner.marginHeight = 0; - gridTimesSpinner.marginWidth = 0; - gridTimesSpinner.horizontalSpacing = 5; - gridTimesSpinner.verticalSpacing = 0; - gridTimesSpinner.makeColumnsEqualWidth = true; - gridTimesSpinner.marginLeft = 5; - gridTimesSpinner.marginRight = 5; - layoutTimeSpinners.setLayout(gridTimesSpinner); - - GridData gridDataCurrentEvent = new GridData(); - gridDataCurrentEvent.horizontalAlignment = SWT.LEFT; - gridDataCurrentEvent.verticalAlignment = SWT.CENTER; - ntgCurrentEventTime = new TimeTextGroup(this, layoutTimeSpinners, SWT.BORDER, SWT.BORDER, CURRENT_EVENT_TIME_LABEL_TEXT, HistogramConstant.formatNanoSecondsTime(0L), doesTimeTextGroupNeedAdjustment); - ntgCurrentEventTime.setLayoutData(gridDataCurrentEvent); - - GridData gridDataTimeSpan = new GridData(); - gridDataTimeSpan.horizontalAlignment = SWT.CENTER; - gridDataTimeSpan.verticalAlignment = SWT.CENTER; - ntgWindowTimeSpan = new TimeTextGroup(this, layoutTimeSpinners, SWT.BORDER, SWT.BORDER, WINDOW_TIMESPAN_LABEL_TEXT, HistogramConstant.formatNanoSecondsTime(0L), doesTimeTextGroupNeedAdjustment); - ntgWindowTimeSpan.setLayoutData(gridDataTimeSpan); - - GridData gridDataWindowCenter = new GridData(); - gridDataWindowCenter.horizontalAlignment = SWT.RIGHT; - gridDataWindowCenter.verticalAlignment = SWT.CENTER; - ntgWindowCenterTime = new TimeTextGroup(this, layoutTimeSpinners, SWT.BORDER, SWT.BORDER, WINDOW_CENTER_TIME_LABEL_TEXT, HistogramConstant.formatNanoSecondsTime(0L), doesTimeTextGroupNeedAdjustment); - ntgWindowCenterTime.setLayoutData(gridDataWindowCenter); - - - ///////////////////////////////////////////////////////////////////////////////////// - // Layout that contain the SelectionWindow - // Contains : - // Label txtWindowStartTime - // Label txtWindowStopTime - // Label txtWindowMaxNbEvents - // Label txtWindowMinNbEvents - // ChildrenHistogramCanvas selectedWindowCanvas - ///////////////////////////////////////////////////////////////////////////////////// - Composite layoutSelectionWindow = new Composite(layoutFullView, SWT.FILL); - GridLayout gridSelectionWindow = new GridLayout(); - gridSelectionWindow.numColumns = 3; - gridSelectionWindow.marginHeight = 0; - gridSelectionWindow.marginWidth = 2; - gridSelectionWindow.marginTop = 5; - gridSelectionWindow.horizontalSpacing = 0; - gridSelectionWindow.verticalSpacing = 0; - layoutSelectionWindow.setLayout(gridSelectionWindow); - - GridData gridDataSelectionWindow = new GridData(); - gridDataSelectionWindow.horizontalAlignment = SWT.FILL; - gridDataSelectionWindow.verticalAlignment = SWT.FILL; - layoutSelectionWindow.setLayoutData(gridDataSelectionWindow); - - GridData gridDataSelectionWindowCanvas = new GridData(); - gridDataSelectionWindowCanvas.horizontalSpan = 2; - gridDataSelectionWindowCanvas.verticalSpan = 2; - gridDataSelectionWindowCanvas.horizontalAlignment = SWT.FILL; - gridDataSelectionWindowCanvas.grabExcessHorizontalSpace = true; - gridDataSelectionWindowCanvas.verticalAlignment = SWT.FILL; -/* - // 2010-06-20 Yuriy - gridDataSelectionWindowCanvas.heightHint = SELECTED_WINDOW_CANVAS_HEIGHT; - gridDataSelectionWindowCanvas.minimumHeight = SELECTED_WINDOW_CANVAS_HEIGHT; -*/ - gridDataSelectionWindowCanvas.widthHint = selectedCanvasWidth; - gridDataSelectionWindowCanvas.minimumWidth = selectedCanvasWidth; - selectedWindowCanvas = new ChildrenHistogramCanvas(this, layoutSelectionWindow, SWT.BORDER); - selectedWindowCanvas.setLayoutData(gridDataSelectionWindowCanvas); - - GridData gridDataWindowMaxEvents = new GridData(); - gridDataWindowMaxEvents.horizontalAlignment = SWT.RIGHT; - gridDataWindowMaxEvents.verticalAlignment = SWT.TOP; - // Force a width, to avoid the control to enlarge if the number of events change - gridDataWindowMaxEvents.minimumWidth = nbEventWidth; - txtWindowMaxNbEvents = new Text(layoutSelectionWindow, SWT.READ_ONLY); - txtWindowMaxNbEvents.setFont(smallFont); - txtWindowMaxNbEvents.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - txtWindowMaxNbEvents.setEditable(false); - txtWindowMaxNbEvents.setText("0"); //$NON-NLS-1$ - txtWindowMaxNbEvents.setLayoutData(gridDataWindowMaxEvents); - - GridData gridDataWindowMinEvents = new GridData(); - gridDataWindowMinEvents.horizontalAlignment = SWT.RIGHT; - gridDataWindowMinEvents.verticalAlignment = SWT.BOTTOM; - // Force a width, to avoid the control to enlarge if the number of events change - gridDataWindowMinEvents.minimumWidth = nbEventWidth; - txtWindowMinNbEvents = new Text(layoutSelectionWindow, SWT.READ_ONLY); - txtWindowMinNbEvents.setFont(smallFont); - txtWindowMinNbEvents.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - txtWindowMinNbEvents.setEditable(false); - txtWindowMinNbEvents.setText("0"); //$NON-NLS-1$ - txtWindowMinNbEvents.setLayoutData(gridDataWindowMinEvents); - - GridData gridDataWindowStart = new GridData(); - gridDataWindowStart.horizontalAlignment = SWT.LEFT; - gridDataWindowStart.verticalAlignment = SWT.BOTTOM; - txtWindowStartTime = new Text(layoutSelectionWindow, SWT.READ_ONLY); - txtWindowStartTime.setFont(smallFont); - txtWindowStartTime.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - txtWindowStartTime.setEditable(false); - txtWindowStartTime.setText("0.000000000"); //$NON-NLS-1$ - txtWindowStartTime.setLayoutData(gridDataWindowStart); - - GridData gridDataWindowStop = new GridData(); - gridDataWindowStop.horizontalAlignment = SWT.RIGHT; - gridDataWindowStop.verticalAlignment = SWT.BOTTOM; - txtWindowStopTime = new Text(layoutSelectionWindow, SWT.READ_ONLY); - txtWindowStopTime.setFont(smallFont); - txtWindowStopTime.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - txtWindowStopTime.setEditable(false); - txtWindowStopTime.setText("0.000000000"); //$NON-NLS-1$ - txtWindowStopTime.setLayoutData(gridDataWindowStop); - - -/* - // 2010-06-10 Yuriy: NOT NEEDED AFTER GUI IMPROVEMENTS. WORK FINE WITOUT THIS HACK - // *** HACK *** - // To align properly AND to make sure the canvas size is fixed, we NEED to make sure all "section" of the - // gridlayout are taken (and if possible of a fixed size). - // However, SWT is VERY VERY DUMB and won't consider griddata that contain no control. - // Since there will be missing a section, the SelectedWindowCanvas + NbEventsText will take 3 spaces, but - // startTimeText + stopTimeText will take only 2 (as if empty the other griddata of 1 will get ignored). - // StopTime will then take over the missing space; I want to align "stopTime" right on the end of canvas, so - // the added space to stop time would make it being aligned improperly - // So I NEED the empty griddata to be considered! - // Visually : - // |---------------|---------------|-----------| - // |SelectionCanvas SelectionCanvas|NbEventText| - // |SelectionCanvas SelectionCanvas|NbEventText| - // |---------------|---------------|-----------| - // |StartTime | StopTime| ??? | - // |---------------|---------------|-----------| - // - // So since SWT will only consider griddata with control, - // I need to create a totally useless control in the ??? section. - // That's ugly, useless and it is generally a bad practice. - // - // *** SUB-HACK *** - // Other interesting fact about SWT : the way it draws (Fill/Expand control in grid) will change if - // the control is a Text or a Label. - // A Label here will be "pushed" by startTime/stopTime Text and won't fill the full space as NbEventText. - // A Text here will NOT be "pushed" and would give a nice visual output. - // (NB : No, I am NOT kidding, try it for yourself!) - // - // Soooooo I guess I will use a Text here. Way to go SWT! - // Downside is that disabled textbox has a slightly different color (even if you force it yourself) so if I want - // to make the text "invisible", I have to keep it enabled (but read only), so it can be clicked on. - // - // Label uselessControlToByPassSWTStupidBug = new Label(layoutSelectionWindow, SWT.BORDER); // WON'T align correctly!!! - //GridData gridDataSpacer = new GridData(SWT.FILL, SWT.TOP, true, true, 1, 1); - GridData gridDataSpacer = new GridData(); - gridDataWindowStop.horizontalAlignment = SWT.FILL; - gridDataWindowStop.verticalAlignment = SWT.TOP; - gridDataSpacer.minimumWidth = nbEventWidth; - Text uselessControlToByPassSWTStupidBug = new Text(layoutSelectionWindow, SWT.READ_ONLY); // WILL align correctly!!! - uselessControlToByPassSWTStupidBug.setEditable(false); - uselessControlToByPassSWTStupidBug.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - uselessControlToByPassSWTStupidBug.setLayoutData(gridDataSpacer); -*/ - - - ///////////////////////////////////////////////////////////////////////////////////// - // Layout that contain the complete experiment histogram and related controls. - // Contains : - // ParentHistogramCanvas fullExperimentCanvas - // Text txtExperimentStartTime - // Text txtExperimentStopTime - ///////////////////////////////////////////////////////////////////////////////////// - Composite layoutExperimentHistogram = new Composite(layoutFullView, SWT.FILL); - - GridLayout gridExperimentHistogram = new GridLayout(); - gridExperimentHistogram.numColumns = 2; - gridExperimentHistogram.marginHeight = 0; - gridExperimentHistogram.marginWidth = 0; - gridExperimentHistogram.horizontalSpacing = 0; - gridExperimentHistogram.verticalSpacing = 0; - gridExperimentHistogram.marginLeft = 5; - gridExperimentHistogram.marginRight = 5; - layoutExperimentHistogram.setLayout(gridExperimentHistogram); - -/* - // 2010-06-10 Yuriy: NOT NEEDED AFTER GUI IMPROVEMENTS - GridData gridDataExperimentHistogram = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1); - layoutExperimentHistogram.setLayoutData(gridDataExperimentHistogram); -*/ - - // *** Everything related to the experiment canvas is below - GridData gridDataExperimentCanvas = new GridData(); - gridDataExperimentCanvas.horizontalSpan = 2; - gridDataExperimentCanvas.horizontalAlignment = SWT.FILL; - gridDataExperimentCanvas.grabExcessHorizontalSpace = true; - gridDataExperimentCanvas.verticalAlignment = SWT.FILL; - gridDataExperimentCanvas.grabExcessVerticalSpace = true; -/* - // 2010-06-20 Yuriy: We use the dynamic height. - gridDataExperimentCanvas.heightHint = FULL_TRACE_CANVAS_HEIGHT; - gridDataExperimentCanvas.minimumHeight = FULL_TRACE_CANVAS_HEIGHT; -*/ - fullExperimentCanvas = new ParentHistogramCanvas(this, layoutExperimentHistogram, SWT.BORDER); - fullExperimentCanvas.setLayoutData(gridDataExperimentCanvas); - layoutExperimentHistogram.setLayoutData(gridDataExperimentCanvas); - - GridData gridDataExperimentStart = new GridData(); - gridDataExperimentStart.horizontalAlignment = SWT.LEFT; - gridDataExperimentStart.verticalAlignment = SWT.BOTTOM; - txtExperimentStartTime = new Text(layoutExperimentHistogram, SWT.READ_ONLY); - txtExperimentStartTime.setFont(smallFont); - txtExperimentStartTime.setText("0.000000000"); //$NON-NLS-1$ - txtExperimentStartTime.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - txtExperimentStartTime.setEditable(false); - txtExperimentStartTime.setLayoutData(gridDataExperimentStart); - - GridData gridDataExperimentStop = new GridData(); - gridDataExperimentStop.horizontalAlignment = SWT.RIGHT; - gridDataExperimentStop.verticalAlignment = SWT.BOTTOM; - txtExperimentStopTime = new Text(layoutExperimentHistogram, SWT.READ_ONLY); - txtExperimentStopTime.setFont(smallFont); - txtExperimentStopTime.setText("0.000000000"); //$NON-NLS-1$ - txtExperimentStopTime.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND)); - txtExperimentStopTime.setEditable(false); - txtExperimentStopTime.setLayoutData(gridDataExperimentStop); - } - - // *** FIXME *** - // This is mainly used because of a because in the "experimentSelected()" notification, we shouldn't need this - /** - * Method called when the view receive the focus.<p> - * If ExperimentSelected didn't send us a request yet, get the current Experiment and fire requests - */ - @SuppressWarnings("unchecked") - @Override - public void setFocus() { - // WARNING : This does not seem to be thread safe - TmfExperiment<LttngEvent> tmpExperiment = (TmfExperiment<LttngEvent>)TmfExperiment.getCurrentExperiment(); - - if ( (dataBackgroundFullRequest == null) && (tmpExperiment != null) ) { - createCanvasAndRequests(tmpExperiment); - } - - // Call a redraw for everything - parent.redraw(); - } - - /** - * Method called when the user select (double-click on) an experiment.<p> - * We will create the needed canvas and fire the requests. - * - * @param signal Signal received from the framework. Contain the experiment. - */ + + // The initial window span (in nanoseconds) + public static long INITIAL_WINDOW_SPAN = (1L * 100 * 1000 * 1000); // .1sec + + // Time scale + private final byte TIME_SCALE = Histogram.TIME_SCALE; + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + // Parent widget + private Composite fParent; + + // The current experiment + private TmfExperiment<LttngEvent> fCurrentExperiment; + + // Current timestamp/time window + private long fExperimentStartTime; + private long fExperimentEndTime; + private long fWindowStartTime; + private long fWindowEndTime; + private long fWindowSpan = INITIAL_WINDOW_SPAN; + private long fCurrentTimestamp; + + // Time controls + private HistogramTextControl fCurrentEventTimeControl; + private HistogramTextControl fTimeSpanControl; + + // Histogram/request for the full trace range + private static FullTraceHistogram fFullTraceHistogram; + private HistogramRequest fFullTraceRequest; + + // Histogram/request for the selected time range + private static TimeRangeHistogram fTimeRangeHistogram; + private HistogramRequest fTimeRangeRequest; + + // ------------------------------------------------------------------------ + // Constructor + // ------------------------------------------------------------------------ + + public HistogramView() { + super(ID); + } + + public void dispose() { + fFullTraceHistogram.dispose(); + fTimeRangeHistogram.dispose(); + } + + // ------------------------------------------------------------------------ + // TmfView + // ------------------------------------------------------------------------ + + @Override @SuppressWarnings("unchecked") - @TmfSignalHandler - public void experimentSelected(TmfExperimentSelectedSignal<LttngEvent> signal) { - TmfExperiment<LttngEvent> tmpExperiment = (TmfExperiment<LttngEvent>)signal.getExperiment(); - createCanvasAndRequests(tmpExperiment); + public void createPartControl(Composite parent) { + + fParent = parent; + + // Control labels + final String currentEventLabel = Messages.HistogramView_currentEventLabel; + final String windowSpanLabel = Messages.HistogramView_windowSpanLabel; + + // -------------------------------------------------------------------- + // Set the HistogramView layout + // -------------------------------------------------------------------- + + Composite viewComposite = new Composite(fParent, SWT.FILL); + GridLayout gridLayout = new GridLayout(); + gridLayout.numColumns = 2; + gridLayout.horizontalSpacing = 5; + gridLayout.verticalSpacing = 0; + gridLayout.marginHeight = 0; + gridLayout.marginWidth = 0; + viewComposite.setLayout(gridLayout); + + // Use all available space + GridData gridData = new GridData(); + gridData.horizontalAlignment = SWT.FILL; + gridData.verticalAlignment = SWT.FILL; + gridData.grabExcessHorizontalSpace = true; + viewComposite.setLayoutData(gridData); + + // -------------------------------------------------------------------- + // Time controls + // -------------------------------------------------------------------- + + Composite controlsComposite = new Composite(viewComposite, SWT.FILL); + gridLayout = new GridLayout(); + gridLayout.numColumns = 2; + gridLayout.marginHeight = 0; + gridLayout.marginWidth = 0; + gridLayout.horizontalSpacing = 5; + gridLayout.verticalSpacing = 0; + gridLayout.makeColumnsEqualWidth = true; + gridLayout.marginLeft = 5; + gridLayout.marginRight = 5; + controlsComposite.setLayout(gridLayout); + + // Current event time control + gridData = new GridData(); + gridData.horizontalAlignment = SWT.CENTER; + gridData.verticalAlignment = SWT.CENTER; + fCurrentEventTimeControl = new HistogramCurrentTimeControl(this, controlsComposite, SWT.BORDER, SWT.BORDER, currentEventLabel, + HistogramUtils.nanosecondsToString(0L)); + fCurrentEventTimeControl.setLayoutData(gridData); + + // Window span time control + gridData = new GridData(); + gridData.horizontalAlignment = SWT.CENTER; + gridData.verticalAlignment = SWT.CENTER; + fTimeSpanControl = new HistogramTimeRangeControl(this, controlsComposite, SWT.BORDER, SWT.BORDER, windowSpanLabel, + HistogramUtils.nanosecondsToString(0L)); + fTimeSpanControl.setLayoutData(gridData); + + // -------------------------------------------------------------------- + // Time range histogram + // -------------------------------------------------------------------- + + Composite timeRangeComposite = new Composite(viewComposite, SWT.FILL); + gridLayout = new GridLayout(); + gridLayout.numColumns = 1; + gridLayout.marginHeight = 0; + gridLayout.marginWidth = 0; + gridLayout.marginTop = 5; + gridLayout.horizontalSpacing = 0; + gridLayout.verticalSpacing = 0; + gridLayout.marginLeft = 5; + gridLayout.marginRight = 5; + timeRangeComposite.setLayout(gridLayout); + + // Use remaining horizontal space + gridData = new GridData(); + gridData.horizontalAlignment = SWT.FILL; + gridData.verticalAlignment = SWT.FILL; + gridData.grabExcessHorizontalSpace = true; + timeRangeComposite.setLayoutData(gridData); + + // Histogram + fTimeRangeHistogram = new TimeRangeHistogram(this, timeRangeComposite); + + // -------------------------------------------------------------------- + // Full range histogram + // -------------------------------------------------------------------- + + Composite fullRangeComposite = new Composite(viewComposite, SWT.FILL); + gridLayout = new GridLayout(); + gridLayout.numColumns = 1; + gridLayout.marginHeight = 0; + gridLayout.marginWidth = 0; + gridLayout.marginTop = 5; + gridLayout.horizontalSpacing = 0; + gridLayout.verticalSpacing = 0; + gridLayout.marginLeft = 5; + gridLayout.marginRight = 5; + fullRangeComposite.setLayout(gridLayout); + + // Use remaining horizontal space + gridData = new GridData(); + gridData.horizontalAlignment = SWT.FILL; + gridData.verticalAlignment = SWT.FILL; + gridData.horizontalSpan = 2; + gridData.grabExcessHorizontalSpace = true; + fullRangeComposite.setLayoutData(gridData); + + // Histogram + fFullTraceHistogram = new FullTraceHistogram(this, fullRangeComposite); + + // Load the experiment if present + fCurrentExperiment = (TmfExperiment<LttngEvent>) TmfExperiment.getCurrentExperiment(); + if (fCurrentExperiment != null) + loadExperiment(); } - - - // *** VERIFY *** - // Not sure what this should do since I don't know when it will be called - // Let's do the same thing as experimentSelected for now - // - /** - * Method called when an experiment is updated (??).<p> - * ...for now, do nothing, as udating an experiment running in the background might cause crash - * - * @param signal Signal received from the framework. Contain the experiment. - */ -/* + + @Override @SuppressWarnings("unchecked") - @TmfSignalHandler - public void experimentUpdated(TmfExperimentUpdatedSignal signal) { - - TmfExperiment<LttngEvent> tmpExperiment = (TmfExperiment<LttngEvent>)signal.getExperiment(); - - // Make sure the UI object are sane - resetControlsContent(); - - // Redraw the canvas right away to have something "clean" as soon as we can - fullExperimentCanvas.redraw(); - selectedWindowCanvas.redraw(); - - // Recreate the request - createCanvasAndRequests(tmpExperiment); + public void setFocus() { + TmfExperiment<LttngEvent> experiment = (TmfExperiment<LttngEvent>) TmfExperiment.getCurrentExperiment(); + if ((experiment != null) && (experiment != fCurrentExperiment)) { + fCurrentExperiment = experiment; + initializeHistograms(); + } + fParent.redraw(); } -*/ - - /** - * Method called when synchronization is active and that the user select an event. - * We update the current event timeTextGroup and move the selected window if needed. - * - * @param signal Signal received from the framework. Contain the event. - */ - @TmfSignalHandler - public void currentTimeUpdated(TmfTimeSynchSignal signal) { - // In case we received our own signal - if ( (signal != null) && (signal.getSource() != this) ) { - TmfTimestamp currentTime = signal.getCurrentTime(); - - // Update the current event controls - currentEventTime = currentTime.getValue(); - updateSelectedEventTime(); + + // ------------------------------------------------------------------------ + // Accessors + // ------------------------------------------------------------------------ + + public TmfTimeRange getTimeRange() { + return new TmfTimeRange(new TmfTimestamp(fWindowStartTime, TIME_SCALE), new TmfTimestamp(fWindowEndTime, TIME_SCALE)); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + public void updateCurrentEventTime(long newTime) { + if (fCurrentExperiment != null) { + TmfTimeRange timeRange = new TmfTimeRange(new TmfTimestamp(newTime, TIME_SCALE), TmfTimestamp.BigCrunch); + HistogramRequest request = new HistogramRequest(fTimeRangeHistogram, timeRange, 1, ExecutionType.FOREGROUND) { + @Override + public void handleData(LttngEvent event) { + if (event != null) { + TmfTimeSynchSignal signal = new TmfTimeSynchSignal(this, event.getTimestamp()); + TmfSignalManager.dispatchSignal(signal); + } + } + }; + fCurrentExperiment.sendRequest(request); + } + } + + public void updateTimeRange(long startTime, long endTime) { + if (fCurrentExperiment != null) { + // Build the new time range; keep the current time + TmfTimeRange timeRange = new TmfTimeRange(new TmfTimestamp(startTime, TIME_SCALE), new TmfTimestamp(endTime, TIME_SCALE)); + TmfTimestamp currentTime = new TmfTimestamp(fCurrentTimestamp, TIME_SCALE); - // If the given event is outside the selection window, recenter the window - if ( isGivenTimestampInSelectedWindow( currentEventTime ) == false) { - fullExperimentCanvas.setWindowCenterPosition(currentEventTime); - - // Notify control that the window changed - windowChangedNotification(); - // Send a broadcast to the framework about the window change - sendTmfRangeSynchSignalBroadcast(); - } - } + fTimeSpanControl.setValue(endTime - startTime); + + // Send the FW signal + TmfRangeSynchSignal signal = new TmfRangeSynchSignal(this, timeRange, currentTime); + TmfSignalManager.dispatchSignal(signal); + } + } + + public synchronized void updateTimeRange(long newDuration) { + if (fCurrentExperiment != null) { + long delta = newDuration - fWindowSpan; + long newStartTime = fWindowStartTime + delta / 2; + setNewRange(newStartTime, newDuration); + } + } + + private void setNewRange(long startTime, long duration) { + if (startTime < fExperimentStartTime) + startTime = fExperimentStartTime; + + long endTime = startTime + duration; + if (endTime > fExperimentEndTime) { + endTime = fExperimentEndTime; + if (endTime - duration > fExperimentStartTime) + startTime = endTime - duration; + else { + startTime = fExperimentStartTime; + } + } + updateTimeRange(startTime, endTime); } - + + // ------------------------------------------------------------------------ + // Signal handlers + // ------------------------------------------------------------------------ + @TmfSignalHandler - public void synchToTimeRange(TmfRangeSynchSignal signal) { - if ( (signal != null) ) { - if ( lastUsedExperiment != null ) { - long currentTime = signal.getCurrentTime().getValue(); - long windowStart = signal.getCurrentRange().getStartTime().getValue(); - long windowEnd = signal.getCurrentRange().getEndTime().getValue(); - long windowTimeWidth = (windowEnd - windowStart); - - // Recenter the window - fullExperimentCanvas.setSelectedWindowSize(windowTimeWidth); - fullExperimentCanvas.setWindowCenterPosition( fullExperimentCanvas.getHistogramContent().getClosestXPositionFromTimestamp(windowStart + (windowTimeWidth/2)) ); - - // *** HACK *** - // Views could send us incorrect current event value (event outside the current window) - // Here we make sure the value is sane, otherwise, we force it as the left border of the window - if ( isGivenTimestampInSelectedWindow( currentTime ) == false ) { - currentTime = windowStart; - } - currentEventTime = currentTime; - - // Notify control that the window changed - windowChangedNotification(); - - // Make sure we redraw the change - fullExperimentCanvas.redraw(); - } - } - } - - - /* - * Create the canvas needed and issue the requests - * - * @param newExperiment Experiment we will use for the request - */ - private void createCanvasAndRequests(TmfExperiment<LttngEvent> newExperiment) { - // Save the experiment we are about to use - lastUsedExperiment = newExperiment; - -// // Create a copy of the trace that will be use only by the full experiment request -// TmfExperiment<LttngEvent> experimentCopy = newExperiment.createTraceCopy(); - - // Create the content for the full experiment. - // This NEED to be created first, as we use it in the selectedWindowCanvas - fullExperimentCanvas.createNewHistogramContent( - fullExperimentCanvas.getSize().x, - FULL_TRACE_BAR_WIDTH, -/* - // 2010-06-20 Yuriy: We will use the dynamic height. - FULL_TRACE_CANVAS_HEIGHT -*/ - fullExperimentCanvas.getSize().y / 2, - FULL_TRACE_DIFFERENCE_TO_AVERAGE - ); - - TmfTimeRange timeRange = getExperimentTimeRange(newExperiment); - - // We will take the half of the full experiment length in case of bigger window size than the full experiment length - if(timeRange.getEndTime().getValue() - timeRange.getStartTime().getValue() > DEFAULT_WINDOW_SIZE ) { - fullExperimentCanvas.createNewSelectedWindow( - timeRange.getStartTime().getValue(), - DEFAULT_WINDOW_SIZE - ); - } else { - fullExperimentCanvas.createNewSelectedWindow( - timeRange.getStartTime().getValue(), - (timeRange.getEndTime().getValue() - timeRange.getStartTime().getValue() ) / 2 - ); - } - - currentEventTime = timeRange.getStartTime().getValue(); - - // Set the window of the fullTrace canvas visible. - fullExperimentCanvas.getCurrentWindow().setSelectedWindowVisible(true); - fullExperimentCanvas.getHistogramContent().resetTable(timeRange.getStartTime().getValue(), timeRange.getEndTime().getValue()); - - // Create the content for the selected window. - selectedWindowCanvas.createNewHistogramContent( - selectedWindowCanvas.getSize().x, - SELECTED_WINDOW_BAR_WIDTH, - selectedWindowCanvas.getSize().y, - SELECTED_WINDOW_DIFFERENCE_TO_AVERAGE - ); - selectedWindowCanvas.getHistogramContent().resetTable(fullExperimentCanvas.getCurrentWindow().getTimestampOfLeftPosition(), fullExperimentCanvas.getCurrentWindow().getTimestampOfRightPosition()); - - // Make sure the UI object are sane - resetControlsContent(); - - // Redraw the canvas right away to have something "clean" as soon as we can - if ( dataBackgroundFullRequest != null ) { - fullExperimentCanvas.redraw(); - selectedWindowCanvas.redraw(); - } - // Nullify the (possible) old request to be sure we start we something clean - // Note : this is very important for the order of the request below, - // see "TODO" in performSelectedWindowEventsRequest - dataBackgroundFullRequest = null; - selectedWindowRequest = null; - - // Perform both request. - // Order is important here, the small/synchronous request for the selection window should go first - performSelectedWindowEventsRequest(newExperiment); - performAllTraceEventsRequest(newExperiment); + @SuppressWarnings("unchecked") + public void experimentSelected(TmfExperimentSelectedSignal<LttngEvent> signal) { + assert (signal != null); + fCurrentExperiment = (TmfExperiment<LttngEvent>) signal.getExperiment(); + loadExperiment(); } - // Before completing its indexing, the experiment doesn't know start/end time. - // However, LTTng individual traces have this knowledge so we should ask them - // directly. - private TmfTimeRange getExperimentTimeRange(TmfExperiment<LttngEvent> experiment) { - // Before completing its indexing, the experiment doesn't know start/end time. - // However, LTTng individual traces have this knowledge so we should ask them - // directly. - TmfTimestamp startTime = TmfTimestamp.BigCrunch; - TmfTimestamp endTime = TmfTimestamp.BigBang; - for (ITmfTrace trace : experiment.getTraces()) { - TmfTimestamp traceStartTime = trace.getStartTime(); - if (traceStartTime.compareTo(startTime, true) < 0) - startTime = traceStartTime; - TmfTimestamp traceEndTime = trace.getEndTime(); - if (traceEndTime.compareTo(endTime, true) > 0) - endTime = traceEndTime; - } - TmfTimeRange tmpRange = new TmfTimeRange(startTime, endTime); - return tmpRange; + private void loadExperiment() { + fExperimentStartTime = fCurrentExperiment.getStartTime().getValue(); + fExperimentEndTime = fCurrentExperiment.getEndTime().getValue(); + fCurrentTimestamp = fExperimentStartTime; + initializeHistograms(); + fParent.redraw(); } - /** - * Perform a new request for the Selection window.<p> - * This assume the full experiment canvas has correct information about the selected window; - * we need the fullExperimentCanvas' HistogramContent to be created and a selection window to be set. - * - * @param experiment The experiment we will select from - */ - public void performSelectedWindowEventsRequest(TmfExperiment<LttngEvent> experiment) { - - if(fullExperimentCanvas != null) { - HistogramSelectedWindow curSelectedWindow = fullExperimentCanvas.getCurrentWindow(); - - TmfTimeRange timeRange = getExperimentTimeRange(experiment); - - // If no selection window exists, we will try to create one; - // however this will most likely fail as the content is probably not created either - if ( curSelectedWindow == null ) { - // We will take the half of the full experiment length in case of bigger window size than the full experiment length - if(timeRange.getEndTime().getValue() - timeRange.getStartTime().getValue() > DEFAULT_WINDOW_SIZE ) { - fullExperimentCanvas.createNewSelectedWindow( - timeRange.getStartTime().getValue(), - DEFAULT_WINDOW_SIZE - ); - } else { - fullExperimentCanvas.createNewSelectedWindow( - timeRange.getStartTime().getValue(), - (timeRange.getEndTime().getValue() - timeRange.getStartTime().getValue() ) / 2 - ); - } - curSelectedWindow = fullExperimentCanvas.getCurrentWindow(); - } - - // The request will go from the Left timestamp of the window to the Right timestamp - // This assume that out-of-bound value are handled by the SelectionWindow itself - LttngTimestamp ts1 = new LttngTimestamp( curSelectedWindow.getTimestampOfLeftPosition() ); - LttngTimestamp ts2 = new LttngTimestamp( curSelectedWindow.getTimestampOfRightPosition() ); - TmfTimeRange tmpRange = new TmfTimeRange(ts1, ts2); - - // Set a (dynamic) time interval - long intervalTime = ( (ts2.getValue() - ts1.getValue()) / selectedWindowCanvas.getHistogramContent().getNbElement() ); - - selectedWindowRequest = performRequest(experiment, selectedWindowCanvas, tmpRange, intervalTime, ExecutionType.FOREGROUND); - selectedWindowCanvas.redrawAsynchronously(); - } - +// @TmfSignalHandler +// @SuppressWarnings("unchecked") +// public void experimentUpdated(TmfExperimentUpdatedSignal signal) { +// fCurrentExperiment = (TmfExperiment<LttngEvent>) signal.getExperiment(); +// fFullRangeHistogramCanvas.redraw(); +// fTimespanHistogramCanvas.redraw(); +// createCanvasAndRequests(); +// } + + @TmfSignalHandler + public void currentTimeUpdated(TmfTimeSynchSignal signal) { + // Because this can't happen :-) + assert (signal != null); + + // Update the selected event time + TmfTimestamp currentTime = signal.getCurrentTime(); + fCurrentTimestamp = currentTime.getValue(); + + // Notify the relevant widgets + fFullTraceHistogram.setCurrentEvent(fCurrentTimestamp); + fTimeRangeHistogram.setCurrentEvent(fCurrentTimestamp); + fCurrentEventTimeControl.setValue(fCurrentTimestamp); } - - /** - * Perform a new request for the full experiment.<p> - * NOTE : this is very long, we need to implement a way to run this in parallel (see TODO) - * - * @param experiment The experiment we will select from - */ - public void performAllTraceEventsRequest(TmfExperiment<LttngEvent> experiment) { - // Create a new time range from "start" to "end" - // That way, we will get "everything" in the trace -// LttngTimestamp ts1 = new LttngTimestamp( experiment.getStartTime() ); -// LttngTimestamp ts2 = new LttngTimestamp( experiment.getEndTime() ); -// TmfTimeRange tmpRange = new TmfTimeRange(ts1, ts2); - - TmfTimeRange tmpRange = getExperimentTimeRange(experiment); - TmfTimestamp startTime = tmpRange.getStartTime(); - TmfTimestamp endTime = tmpRange.getEndTime(); - - // Set a (dynamic) time interval - long intervalTime = ( (endTime.getValue() - startTime.getValue()) / fullExperimentCanvas.getHistogramContent().getNbElement() ); - - // *** VERIFY *** - // This would enable "fixed interval" instead of dynamic one. - // ... we don't need it, do we? - // - // long intervalTime = ((long)(0.001 * (double)1000000000)); - - // *** TODO *** - // It would be interesting if there was a way to tell the framework to run the request "in parallel" here. - // Mean a completetly independant copy of the Expereiment would be done and we would proceed on that. - // - dataBackgroundFullRequest = performRequest(experiment, fullExperimentCanvas, tmpRange, intervalTime, ExecutionType.BACKGROUND); - - - fullExperimentCanvas.getCurrentWindow().setWindowXPositionLeft(fullExperimentCanvas.getHistogramContent().getClosestXPositionFromTimestamp(fullExperimentCanvas.getCurrentWindow().getTimestampOfLeftPosition())); - fullExperimentCanvas.getCurrentWindow().setWindowXPositionCenter(fullExperimentCanvas.getHistogramContent().getClosestXPositionFromTimestamp(fullExperimentCanvas.getCurrentWindow().getTimestampOfCenterPosition())); - fullExperimentCanvas.getCurrentWindow().setWindowXPositionRight(fullExperimentCanvas.getHistogramContent().getClosestXPositionFromTimestamp(fullExperimentCanvas.getCurrentWindow().getTimestampOfRightPosition())); - fullExperimentCanvas.redrawAsynchronously(); + @TmfSignalHandler + public void timeRangeUpdated(TmfRangeSynchSignal signal) { + // Because this can't happen :-) + assert (signal != null); + + if (fCurrentExperiment != null) { + // Update the time range + fWindowStartTime = signal.getCurrentRange().getStartTime().getValue(); + fWindowEndTime = signal.getCurrentRange().getEndTime().getValue(); + fWindowSpan = fWindowEndTime - fWindowStartTime; + + // Notify the relevant widgets + sendTimeRangeRequest(fWindowStartTime, fWindowEndTime); + fFullTraceHistogram.setTimeRange(fWindowStartTime, fWindowSpan); + fTimeSpanControl.setValue(fWindowSpan); + } } - - // *** VERIFY *** - // This function is synchronized, is it a good idea? - // Tis is done to make sure requests arrive somewhat in order, - // this is especially important when request are issued from different thread. - /** - * Create a new request from the given data and send it to the framework.<p> - * The request will be queued and processed later. - * - * @param experiment The experiment we will process the request on - * @param targetCanvas The canvas that will received the result - * @param newRange The range of the request - * @param newInterval The interval of time we use to store the result into the HistogramContent - */ - private synchronized HistogramRequest performRequest(TmfExperiment<LttngEvent> experiment, HistogramCanvas targetCanvas, TmfTimeRange newRange, long newInterval, ITmfDataRequest.ExecutionType execType) { - HistogramRequest returnedRequest = null; - - // *** FIXME *** - // EVIL BUG! - // We use int.MAX_VALUE because we want every events BUT we don't know the number inside the range. - // HOWEVER, this would cause the request to run forever (or until it reach the end of trace). - // Seeting an EndTime does not seems to stop the request - returnedRequest = new HistogramRequest(newRange, Integer.MAX_VALUE, targetCanvas, newInterval, execType ); + + // ------------------------------------------------------------------------ + // Helper functions + // ------------------------------------------------------------------------ + + private void initializeHistograms() { + updateExperimentTimeRange(fCurrentExperiment); + fTimeRangeHistogram.setFullRange(fExperimentStartTime, fExperimentEndTime); + fTimeRangeHistogram.setTimeRange(fExperimentStartTime, INITIAL_WINDOW_SPAN); + fTimeRangeHistogram.setCurrentEvent(fExperimentStartTime); + + fFullTraceHistogram.setTimeRange(fExperimentStartTime, INITIAL_WINDOW_SPAN); + fFullTraceHistogram.setCurrentEvent(fExperimentStartTime); + + fWindowStartTime = fExperimentStartTime; + fWindowSpan = INITIAL_WINDOW_SPAN; + fWindowEndTime = fWindowStartTime + fWindowSpan; - // Send the request to the framework : it will be queued and processed later - experiment.sendRequest(returnedRequest); + fCurrentEventTimeControl.setValue(fExperimentStartTime); + fTimeSpanControl.setValue(fWindowSpan); - return returnedRequest; + sendTimeRangeRequest(fExperimentStartTime, fExperimentStartTime + fWindowSpan); + sendFullRangeRequest(); } - - /** - * Function used to warn that the selection window changed.<p> - * This might be called because the window moved or because its size changed.<p> - * - * We will update the different control related to the selection window. - */ - public void windowChangedNotification() { - - if ( lastUsedExperiment != null ) { - // If a request is ongoing, try to stop it - if (selectedWindowRequest != null && !selectedWindowRequest.isCompleted()) { - selectedWindowRequest.cancel(); - } - - if(fullExperimentCanvas != null) { - // If the current event time is outside the new window, change the current event - // The new current event will be the one closest to the LEFT side of the new window - if ( isGivenTimestampInSelectedWindow(currentEventTime) == false ) { - currentEventChangeNotification( fullExperimentCanvas.getCurrentWindow().getTimestampOfLeftPosition() ); - } - } - - // Perform a new request to read data about the new window - performSelectedWindowEventsRequest(lastUsedExperiment); - } - } - - /** - * Function used to tell that the current event changed.<p> - * This might be called because the user changed the current event or - * because the last current event is now outside the selection window.<p> - * - * We update the related control and send a signal to notify other views of the new current event. - * - * @param newCurrentEventTime - */ - public void currentEventChangeNotification(long newCurrentEventTime) { - - // Notify other views in the framework - if (currentEventTime != newCurrentEventTime) { - currentEventTime = newCurrentEventTime; - - if ( currentEventTime < fullExperimentCanvas.getHistogramContent().getStartTime() ) { - currentEventTime = fullExperimentCanvas.getHistogramContent().getStartTime(); - } - - if ( currentEventTime > fullExperimentCanvas.getHistogramContent().getEndTime() ) { - currentEventTime = fullExperimentCanvas.getHistogramContent().getEndTime(); - } - - // Update the UI control - updateSelectedEventTime(); + + private void sendTimeRangeRequest(long startTime, long endTime) { + if (fTimeRangeRequest != null && !fTimeRangeRequest.isCompleted()) { + fTimeRangeRequest.cancel(); } + TmfTimestamp startTS = new TmfTimestamp(startTime, TIME_SCALE); + TmfTimestamp endTS = new TmfTimestamp(endTime, TIME_SCALE); + TmfTimeRange timeRange = new TmfTimeRange(startTS, endTS); + + fTimeRangeHistogram.clear(); + fTimeRangeHistogram.setTimeRange(startTime, endTime - startTime); + fTimeRangeRequest = new HistogramRequest(fTimeRangeHistogram, timeRange, ExecutionType.FOREGROUND); + fCurrentExperiment.sendRequest(fTimeRangeRequest); } - - public void sendTmfTimeSynchSignalBroadcast() { - -// System.out.println("sendTmfTimeSynchSignalBroadcast " + System.currentTimeMillis()); - - // Send a signal to the framework - LttngTimestamp tmpTimestamp = new LttngTimestamp(currentEventTime); - broadcast(new TmfTimeSynchSignal(this, tmpTimestamp)); - } - - /** - * Function used to tell that the timerange (window) changed.<p> - * This will most likely be called if the time window is resized. - * - * We send a signal to notify other views of the new timerange. - */ - public void sendTmfRangeSynchSignalBroadcast() { - - if (TmfExperiment.getCurrentExperiment() == null) - return; - - long startTime = fullExperimentCanvas.getCurrentWindow().getTimestampOfLeftPosition(); - if ( startTime < fullExperimentCanvas.getHistogramContent().getStartTime() ) { - startTime = fullExperimentCanvas.getHistogramContent().getStartTime(); - } - LttngTimestamp tmpStartTime = new LttngTimestamp(startTime); - - long endTime = fullExperimentCanvas.getCurrentWindow().getTimestampOfRightPosition(); - if ( endTime > fullExperimentCanvas.getHistogramContent().getEndTime() ) { - endTime = fullExperimentCanvas.getHistogramContent().getEndTime(); - } - LttngTimestamp tmpEndTime = new LttngTimestamp(endTime); - - TmfTimeRange tmpTimeRange = new TmfTimeRange(tmpStartTime, tmpEndTime); - LttngTimestamp tmpEventTime = new LttngTimestamp(currentEventTime); - - // Send a signal to the framework - broadcast(new TmfRangeSynchSignal(this, tmpTimeRange, tmpEventTime)); + + private void sendFullRangeRequest() { + if (fFullTraceRequest != null && !fFullTraceRequest.isCompleted()) { + fFullTraceRequest.cancel(); + } + fFullTraceHistogram.clear(); + TmfTimeRange timeRange = updateExperimentTimeRange(fCurrentExperiment); + fFullTraceRequest = new HistogramRequest(fFullTraceHistogram, timeRange, ExecutionType.BACKGROUND); + fCurrentExperiment.sendRequest(fFullTraceRequest); } - - /** - * Function that will be called when one of the time text group value is changed.<p> - * Since we don't (and can't unless we subclass them) know which one, we check them all. - */ - public void timeTextGroupChangeNotification() { - - if(ntgCurrentEventTime != null) { - // If the user changed the current event time, call the notification - long newCurrentTime = ntgCurrentEventTime.getValue(); - if ( newCurrentTime != currentEventTime ) { - currentEventChangeNotification( newCurrentTime ); - // Send a broadcast to the framework about the window change - sendTmfTimeSynchSignalBroadcast(); - } - } - - if(ntgWindowCenterTime != null && fullExperimentCanvas != null) { - // If the user changed the selected window time, recenter the window and call the notification - long newSelectedWindowTime = ntgWindowCenterTime.getValue(); - if ( newSelectedWindowTime != fullExperimentCanvas.getCurrentWindow().getTimestampOfCenterPosition() ) { - fullExperimentCanvas.setWindowCenterPosition(newSelectedWindowTime); - // Send a broadcast to the framework about the window change - sendTmfRangeSynchSignalBroadcast(); - } - } - - if(ntgWindowTimeSpan != null && fullExperimentCanvas != null) { - // If the user changed the selected window size, resize the window and call the notification - long newSelectedWindowTimeRange = ntgWindowTimeSpan.getValue(); - if ( newSelectedWindowTimeRange != fullExperimentCanvas.getCurrentWindow().getWindowTimeWidth() ) { - fullExperimentCanvas.resizeWindowByAbsoluteTime(newSelectedWindowTimeRange); - // Send a broadcast to the framework about the window change - sendTmfRangeSynchSignalBroadcast(); - } - } - + + private TmfTimeRange updateExperimentTimeRange(TmfExperiment<LttngEvent> experiment) { + TmfTimestamp startTime = TmfTimestamp.BigCrunch; + TmfTimestamp endTime = TmfTimestamp.BigBang; + for (ITmfTrace trace : experiment.getTraces()) { + TmfTimestamp traceStartTime = trace.getStartTime(); + if (traceStartTime.compareTo(startTime, true) < 0) + startTime = traceStartTime; + TmfTimestamp traceEndTime = trace.getEndTime(); + if (traceEndTime.compareTo(endTime, true) > 0) + endTime = traceEndTime; + } + fExperimentStartTime = startTime.getValue(); + fExperimentEndTime = endTime.getValue(); + + return new TmfTimeRange(startTime, endTime); } - - /** - * Getter for the last used experiment.<p> - * This might be different than the current experiment or even null. - * - * @return the last experiment we used in this view - */ - public TmfExperiment<LttngEvent> getLastUsedExperiment() { - return lastUsedExperiment; - } - - /** - * Check if a given timestamp is inside the selection window.<p> - * This assume fullExperimentCanvas contain a valid HistogramContent - * - * @param timestamp the timestamp to check - * - * @return if the time is inside the selection window or not - */ - public boolean isGivenTimestampInSelectedWindow(long timestamp) { - boolean returnedValue = true; - - // If the content is not set correctly, this will return weird (or even null) result - if ( (timestamp < fullExperimentCanvas.getCurrentWindow().getTimestampOfLeftPosition() ) || - (timestamp > fullExperimentCanvas.getCurrentWindow().getTimestampOfRightPosition() ) ) - { - returnedValue = false; - } - - return returnedValue; - } - - /** - * Reset the content of all Controls.<p> - * WARNING : Calls in there are not thread safe and can't be called from different thread than "main" - */ - public void resetControlsContent() { - - TmfExperiment<LttngEvent> tmpExperiment = getLastUsedExperiment(); - - // Use the previous Start and End time, or default if they are not available - String startTime = null; - String stopTime = null; - if ( tmpExperiment != null ) { - startTime = HistogramConstant.formatNanoSecondsTime( tmpExperiment.getStartTime().getValue() ); - stopTime = HistogramConstant.formatNanoSecondsTime( tmpExperiment.getEndTime().getValue() ); - } - else { - startTime = HistogramConstant.formatNanoSecondsTime( 0L ); - stopTime = HistogramConstant.formatNanoSecondsTime( 0L ); - } - - txtExperimentStartTime.setText( startTime ); - txtExperimentStopTime.setText( stopTime ); - txtExperimentStartTime.getParent().layout(); - - txtWindowMaxNbEvents.setText("" + 0); //$NON-NLS-1$ - txtWindowMinNbEvents.setText("" + 0); //$NON-NLS-1$ - txtWindowStartTime.setText( HistogramConstant.formatNanoSecondsTime( 0L ) ); - txtWindowStopTime.setText( HistogramConstant.formatNanoSecondsTime( 0L ) ); - txtWindowStartTime.getParent().layout(); - - ntgWindowCenterTime.setValue( HistogramConstant.formatNanoSecondsTime( 0L ) ); - ntgWindowTimeSpan.setValue( HistogramConstant.formatNanoSecondsTime( 0L ) ); - - // Using "startTime" here can avoid an useless TmfTimeSynchSignal here - // However it look ugly to have only this time - ntgCurrentEventTime.setValue( HistogramConstant.formatNanoSecondsTime( 0L ) ); - } - - /** - * Update the content of the controls related to the full experiment canvas<p> - * WARNING : Calls in there are not thread safe and can't be called from different thread than "main" - */ - public void updateFullExperimentInformation() { - - if(fullExperimentCanvas != null) { - String startTime = HistogramConstant.formatNanoSecondsTime( fullExperimentCanvas.getHistogramContent().getStartTime() ); - String stopTime = HistogramConstant.formatNanoSecondsTime( fullExperimentCanvas.getHistogramContent().getEndTime() ); - - txtExperimentStartTime.setText( startTime ); - txtExperimentStopTime.setText( stopTime ); - } - - // Take one of the parent and call its layout to update control size - // Since both control have the same parent, only one call is needed - txtExperimentStartTime.getParent().layout(); - - // Update the selected window, just in case - // This should give a better user experience and it is low cost - updateSelectedWindowInformation(); - } - - /** - * Update the content of the controls related to the selection window canvas<p> - * WARNING : Calls in there are not thread safe and can't be called from different thread than "main" - */ - public void updateSelectedWindowInformation() { - // Update the timestamp as well - updateSelectedWindowTimestamp(); - - if(selectedWindowCanvas != null) { - txtWindowMaxNbEvents.setText( Long.toString(selectedWindowCanvas.getHistogramContent().getHeighestEventCount()) ); - txtWindowMinNbEvents.setText(Long.toString(0)); - } - - // Refresh the layout - txtWindowMaxNbEvents.getParent().layout(); - } - - /** - * Update the content of the controls related to the timestamp of the selection window<p> - * WARNING : Calls in there are not thread safe and can't be called from different thread than "main" - */ - public void updateSelectedWindowTimestamp() { - - if(selectedWindowCanvas != null) { - String startTime = HistogramConstant.formatNanoSecondsTime( selectedWindowCanvas.getHistogramContent().getStartTime() ); - String stopTime = HistogramConstant.formatNanoSecondsTime( selectedWindowCanvas.getHistogramContent().getEndTime() ); - txtWindowStartTime.setText( startTime ); - txtWindowStopTime.setText( stopTime ); - } - - if(fullExperimentCanvas != null) { - ntgWindowCenterTime.setValue( fullExperimentCanvas.getCurrentWindow().getTimestampOfCenterPosition() ); - ntgWindowTimeSpan.setValue( fullExperimentCanvas.getCurrentWindow().getWindowTimeWidth() ); - - // If the current event time is outside the selection window, recenter our window - if ( isGivenTimestampInSelectedWindow(ntgCurrentEventTime.getValue()) == false ) { - currentEventChangeNotification( fullExperimentCanvas.getCurrentWindow().getTimestampOfCenterPosition() ); - } - } - - // Take one control in each group to call to refresh the layout - // Since both control have the same parent, only one call is needed - txtWindowStartTime.getParent().layout(); - ntgWindowCenterTime.getParent().layout(); - } - - /** - * Update the controls related current event.<p> - * The call here SHOULD be thread safe and can be call from any threads. - */ - public void updateSelectedEventTime() { - ntgCurrentEventTime.setValueAsynchronously(currentEventTime); -// sendTmfTimeSynchSignalBroadcast(); - // Tell the selection canvas which event is currently selected - // This give a nice graphic output - selectedWindowCanvas.getHistogramContent().setSelectedEventTimeInWindow(currentEventTime); - selectedWindowCanvas.redrawAsynchronously(); - } - - /** - * Method called when the view is moved.<p> - * - * Just redraw everything... - * - * @param event The control event generated by the move. - */ - @Override - public void controlMoved(ControlEvent event) { - parent.redraw(); - } - - /** - * Method called when the view is resized.<p> - * - * We will make sure that the size didn't change more than the content size.<p> - * Otherwise we need to perform a new request for the full experiment because we are missing data). - * - * @param event The control event generated by the resize. - */ - @Override - public void controlResized(ControlEvent event) { - - // Ouch! The screen enlarged (screen resolution changed?) so far that we miss content to fill the space. - if ( parent.getDisplay().getBounds().width > fullExperimentCanvas.getHistogramContent().getNbElement() ) { - if ( lastUsedExperiment != null ) { - createCanvasAndRequests(lastUsedExperiment); - } - } - - } - - /* - * Getter of FullExperimentCanvas - * - * @return FullExperimentCanvas object - */ - public static ParentHistogramCanvas getFullExperimentCanvas() { - return fullExperimentCanvas; - } - - /* - * Getter of SelectedWindowCanvas - * - * @return SelectedWindowCanvas object - */ - public static ChildrenHistogramCanvas getSelectedWindowCanvas() { - return selectedWindowCanvas; - } - - - /* - * Getter of DEFAULT_WINDOW_SIZE - * - * @return DEFAULT_WINDOW_SIZE value - */ - public static long getDEFAULT_WINDOW_SIZE() { - return DEFAULT_WINDOW_SIZE; - } - - /** - * Getter for dataBackgroundFullRequest variable - * @return the dataBackgroundFullRequest instance - */ - public HistogramRequest getDataBackgroundFullRequest() { - return dataBackgroundFullRequest; - } - - /** - * Getter for selectedWindowRequest variable - * @return the selectedWindowRequest instance - */ - public HistogramRequest getSelectedWindowRequest() { - return selectedWindowRequest; - } } diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramZoom.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramZoom.java new file mode 100644 index 0000000000..437fb160bf --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramZoom.java @@ -0,0 +1,222 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.events.MouseEvent; +import org.eclipse.swt.events.MouseWheelListener; +import org.eclipse.swt.widgets.Canvas; + +/** + * <b><u>HistogramZoom</u></b> + * <p> + * TODO: Document me... + */ +public class HistogramZoom implements MouseWheelListener { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + + private final static double ZOOM_FACTOR = 0.8; + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + private final Histogram fHistogram; + private final Canvas fCanvas; + + private long fAbsoluteStartTime; + private long fAbsoluteEndTime; + private final long fMinWindowSize; + + private long fRangeStartTime; + private long fRangeDuration; + + private MouseScrollCounter fScrollCounter; + + // ------------------------------------------------------------------------ + // Construction + // ------------------------------------------------------------------------ + + public HistogramZoom(Histogram histogram, Canvas canvas, long start, long end) { + fHistogram = histogram; + fCanvas = canvas; + fAbsoluteStartTime = start; + fAbsoluteEndTime = end; + fMinWindowSize = fCanvas.getBounds().x; + + fRangeStartTime = fAbsoluteStartTime; + fRangeDuration = fAbsoluteStartTime + fMinWindowSize; + + canvas.addMouseWheelListener(this); + } + + // ------------------------------------------------------------------------ + // Accessors + // ------------------------------------------------------------------------ + + public long getStartTime() { + return fRangeStartTime; + } + + public long getEndTime() { + return fRangeStartTime + fRangeDuration; + } + + public long getDuration() { + return fRangeDuration; + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + public synchronized void stop() { + if (fScrollCounter != null) { + fScrollCounter.interrupt(); + fScrollCounter = null; + } + } + + public void setFullRange(long startTime, long endTime) { + fAbsoluteStartTime = startTime; + fAbsoluteEndTime = endTime; + } + + public void setNewRange(long startTime, long duration) { + if (startTime < fAbsoluteStartTime) + startTime = fAbsoluteStartTime; + + long endTime = startTime + duration; + if (endTime > fAbsoluteEndTime) { + endTime = fAbsoluteEndTime; + if (endTime - duration > fAbsoluteStartTime) + startTime = endTime - duration; + else { + startTime = fAbsoluteStartTime; + } + } + + fRangeStartTime = startTime; + fRangeDuration = endTime - startTime; + } + + // ------------------------------------------------------------------------ + // MouseWheelListener + // ------------------------------------------------------------------------ + + private long fMouseTimestamp = 0; + + @Override + public synchronized void mouseScrolled(MouseEvent event) { + if (fScrollCounter == null) { + fScrollCounter = new MouseScrollCounter(this); + fScrollCounter.start(); + fMouseTimestamp = fHistogram.getTimestamp(event.x); + } + fScrollCounter.incrementMouseScroll(event.count); + } + + private synchronized void zoom(int nbClicks) { + // The job is finished + fScrollCounter = null; + + // Compute the new time range + long requestedRange = (nbClicks > 0) ? Math.round(ZOOM_FACTOR * fRangeDuration) : (long) Math.ceil(fRangeDuration * (1.0 / ZOOM_FACTOR)); + + // Perform a proportional zoom wrt the mouse position + double ratio = ((double) (fMouseTimestamp - fRangeStartTime)) / fRangeDuration; + long requestedStart = validateStart(fRangeStartTime + (long) ((fRangeDuration - requestedRange) * ratio)); + long requestedEnd = validateEnd(requestedStart, requestedStart + requestedRange); + requestedStart = validateStart(requestedEnd - requestedRange); + + fHistogram.updateTimeRange(requestedStart, requestedEnd); + } + + private long validateStart(long start) { + if (start < fAbsoluteStartTime) + start = fAbsoluteStartTime; + if (start > fAbsoluteEndTime) + start = fAbsoluteEndTime - fMinWindowSize; + return start; + } + + private long validateEnd(long start, long end) { + if (end > fAbsoluteEndTime) + end = fAbsoluteEndTime; + if (end < start + fMinWindowSize) + end = start + fMinWindowSize; + return end; + } + + // ------------------------------------------------------------------------ + // DelayedMouseScroll + // ------------------------------------------------------------------------ + + private class MouseScrollCounter extends Thread { + + // -------------------------------------------------------------------- + // Constants + // -------------------------------------------------------------------- + + private final static long QUIET_TIME = 100L; + private final static long POLLING_INTERVAL = 10L; + + // -------------------------------------------------------------------- + // Attributes + // -------------------------------------------------------------------- + + private HistogramZoom fZoom = null; + + private long fLastPoolTime = 0L; + private int nbScrollClick = 0; + + // -------------------------------------------------------------------- + // Construction + // -------------------------------------------------------------------- + + public MouseScrollCounter(HistogramZoom zoom) { + fZoom = zoom; + fLastPoolTime = System.currentTimeMillis(); + } + + // -------------------------------------------------------------------- + // Operation + // -------------------------------------------------------------------- + + public void incrementMouseScroll(int nbScrolls) { + fLastPoolTime = System.currentTimeMillis(); + nbScrollClick += nbScrolls; + } + + // -------------------------------------------------------------------- + // Thread + // -------------------------------------------------------------------- + + @Override + public void run() { + while ((System.currentTimeMillis() - fLastPoolTime) < QUIET_TIME) { + try { + Thread.sleep(POLLING_INTERVAL); + } catch (Exception e) { + return; + } + } + // Done waiting. Notify the histogram. + if (!isInterrupted()) + fZoom.zoom(nbScrollClick); + } + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Messages.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Messages.java index 595b21f31c..719ef6299a 100644 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Messages.java +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/Messages.java @@ -1,17 +1,49 @@ +/******************************************************************************* + * Copyright (c) 2009, 2011 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: + * William Bourque - Initial API and implementation + * Francois Chouinard - Cleanup and refactoring + *******************************************************************************/ + package org.eclipse.linuxtools.lttng.ui.views.histogram; import org.eclipse.osgi.util.NLS; +/** + * <b><u>Messages</u></b> + * <p> + */ public class Messages extends NLS { + + // ------------------------------------------------------------------------ + // Constants + // ------------------------------------------------------------------------ + private static final String BUNDLE_NAME = "org.eclipse.linuxtools.lttng.ui.views.histogram.messages"; //$NON-NLS-1$ + public static String HistogramView_currentEventLabel; - public static String HistogramView_windowCenterLabel; - public static String HistogramView_windowSpanLabel; - static { - // initialize resource bundle - NLS.initializeMessages(BUNDLE_NAME, Messages.class); - } - - private Messages() { - } + public static String HistogramView_windowSpanLabel; + + // ------------------------------------------------------------------------ + // Initializer + // ------------------------------------------------------------------------ + + static { + // initialize resource bundle + NLS.initializeMessages(BUNDLE_NAME, Messages.class); + } + + // ------------------------------------------------------------------------ + // Constructor + // ------------------------------------------------------------------------ + + private Messages() { + } + } diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvas.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvas.java deleted file mode 100644 index fb1246ae3f..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvas.java +++ /dev/null @@ -1,485 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-06-20 Yuriy Vashchuk - Histogram optimisations. - * 2010-07-16 Yuriy Vashchuk - Base Histogram class simplification. - * Selection Window related methods has been - * implemented here (Parent Histogram). - *******************************************************************************/ -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; - -/** - * <b><u>ParentHistogramCanvas</u></b> - * <p> - * Extended implementation of the HistogramCanvas. - * <p> - * This canvas goal is to display the "Full experiment" histogram. - */ -public class ParentHistogramCanvas extends HistogramCanvas { - - private ParentHistogramCanvasPaintListener paintListener = null; - private HistogramCanvasMouseListener mouseListener = null; - private HistogramCanvasKeyListener keyListener = null; - private ParentHistogramCanvasControlListener controlListener = null; - - private HistogramSelectedWindow currentWindow = null; - - /** - * ParentHistogramCanvas constructor.<p> - * Same as HistogramCanvas, but receive a parent HistogramView that we can call from here. - * - * @param parent Composite control which will be the parent of the new instance (cannot be null) - * @param Style the style of control to construct - */ - public ParentHistogramCanvas(HistogramView histogramView, Composite parent, int style) { - super(histogramView, parent, style); - - // New selected window, not visible by default - if (histogramView !=null && HistogramView.getFullExperimentCanvas() != null) { - createNewSelectedWindow( - HistogramView.getFullExperimentCanvas().getHistogramContent().getStartTime() + HistogramView.getDEFAULT_WINDOW_SIZE() / 2, - HistogramView.getDEFAULT_WINDOW_SIZE() - ); - } - - // 2010-06-20 Yuriy: Moved from parent class - createAndAddPaintListener(); - createAndAddMouseListener(); - createAndAddKeyListener(); - createAndAddControlListener(); - } - - /** - * Create a new HistogramContent for this HistogramCanvas<p> - * A new <I>empty</I> canvas will then be created. - * - * IMPORTANT NOTE : This implementaton use the next power of 2 to the full screen resolution as the content size. - * This allow us to resize the canvas at low cost (i.e. : no need to reissue a full request) - * We need a "particular" paint listener that know about this. - * - * @param canvasSize Size of the parent canvas. - * @param widthPerBar Width of the histogram "bars" - * @param barsHeight Height of the histogram "bars" - * @param maxBarsDifferenceToAverage Factor used to "chop" bars that are too tall. Set to something big (100.0?) if not needed. - */ - @Override - public void createNewHistogramContent(int canvasSize, int widthPerBar, int barsHeight, double maxBarsDifferenceToAverage) { - - // *** FIXME *** - // Note there MIGHT be some unhandled case, like if the resolution of the screen change - // or if a new screen is plugged. - // Let's ignore them for now. - // - // The maximum size the canvas could ever had - int canvasMaxSize = getParent().getDisplay().getBounds().width; - - // Calculate the power of two superior to the max size - int exp = (int)Math.ceil( Math.log( (double)canvasMaxSize ) / Math.log(2.0) ); - int contentSize = (int)Math.pow(2, exp); - - // Create the content - histogramContent = new HistogramContent( contentSize, canvasSize, widthPerBar, barsHeight, maxBarsDifferenceToAverage); - - // We need to ajust the "maxDifferenceToAverageFactor" as the bars we draw might be slitghly larger than the value asked - // Each "interval" are concatenated when draw so the worst case should be : - // contentSize / (closest power of 2 to canvasMaxSize) - // Ex : if canvasSize is 1500 -> (2048 / 1024) == 2 so maxDiff should be twice larger - // - // Note : this is not perfect, if the screen is resized after we calculate this, the resulting output can be quite ugly - // For this reason, this will be recalculated in the paintListener as well. - double maxBarsDiffFactor = ((double)contentSize / Math.pow(2, exp-1)); - histogramContent.setMaxDifferenceToAverageFactor(maxBarsDiffFactor); - } - - - /* - * Create a histogram paint listener and bind it to this canvas.<p> - * - * Note : This one is a bit particular, as it is made to draw content that is of a power of 2. - * The default one draw content that is relative to the real pixels size. - */ - private void createAndAddPaintListener() { - paintListener = new ParentHistogramCanvasPaintListener(this); - this.addPaintListener( paintListener ); - } - - /* - * Create a histogram mouse listener and bind it to this canvas.<p> - * Note : this mouse listener handle the mouse, the move and the wheel at once. - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasMouseListener - */ - private void createAndAddMouseListener() { - mouseListener = new HistogramCanvasMouseListener(this); - this.addMouseListener(mouseListener); - this.addMouseMoveListener(mouseListener); - this.addMouseWheelListener(mouseListener); - } - - /* - * Create a histogram key listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasKeyListener - */ - private void createAndAddKeyListener() { - keyListener = new HistogramCanvasKeyListener(this); - this.addKeyListener(keyListener); - } - - /* - * Create a histogram control listener and bind it to this canvas.<p> - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramCanvasControlListener - */ - private void createAndAddControlListener() { - controlListener = new ParentHistogramCanvasControlListener(this); - this.addControlListener(controlListener); - } - - /** - * Create a new selection window of the size (time width) given.<p> - * The window initial position is at X = 0. - * The window is created hidden, it won't be draw unless it is set to visible.<p> - * - * @param windowTimeDuration Time width (in nanosecond) of the window. - */ - public void createNewSelectedWindow(long timestampOfLeftPosition, long windowTimeDuration) { - currentWindow = new HistogramSelectedWindow(histogramContent, timestampOfLeftPosition, windowTimeDuration); - } - - /** - * Getter for the selection window<p> - * - * @return the current selection window - * - * @see org.eclipse.linuxtools.lttng.ui.views.histogram.HistogramSelectedWindow - */ - public HistogramSelectedWindow getCurrentWindow() { - return currentWindow; - } - - /** - * Getter for the selection window width<p> - * - * @return Time width (in nanosecond) of the selection window. - */ - public long getSelectedWindowSize() { - return currentWindow.getWindowTimeWidth(); - } - - /** - * Setter for the selection window width<p> - * The window size will be ajusted if it does not respect one of these constraints : - * - The window size cannot be smaller than a single histogram content interval.<p> - * - The window size cannot be larger than twice the histogram content complete time interval.<p> - * - * @param newSelectedWindowSize New time width (in nanosecond) of the selection window. - */ - public void setSelectedWindowSize(long newSelectedWindowSize) { - - if ( newSelectedWindowSize <= 0 ) { - newSelectedWindowSize = 1L; - } - else if ( newSelectedWindowSize > (2*histogramContent.getCompleteTimeInterval()) ) { - newSelectedWindowSize = (2*histogramContent.getCompleteTimeInterval()); - } - - currentWindow.setWindowTimeWidth(newSelectedWindowSize); - } - - /** - * Function that is called when the selection window is moved.<p> - * Note: Given position should be relative to the previous (centered) absolute position.<p> - * - * Calculate the new position then re-center the window.<p> - * It will also notify the HistogramView that the window changed. - * - * @param newRelativeXPosition New position relative to the last known absolute position. - */ - public void moveWindow(int newRelativeXPosition) { - int absolutePosition = currentWindow.getWindowXPositionCenter() + newRelativeXPosition; - - setWindowCenterPosition(absolutePosition); - notifyParentSelectionWindowChangedAsynchronously(); - } - - /** - * Function that is called when the selection window is re-centered.<p> - * Note: Given position should be absolute to the window and need to be the selection window center.<p> - * - * Recenter the window and notify the HistogramView that the window changed. - * - * @param newRelativeXPosition New absolute position. - */ - public void setWindowCenterPosition(int newAbsoluteXPosition) { - - // We will check if the coordinate the same - if ( newAbsoluteXPosition != currentWindow.getWindowXPositionCenter() ) { - - long timestampOfLeftPosition = this.getHistogramContent().getClosestElementFromXPosition( newAbsoluteXPosition ).firstIntervalTimestamp - currentWindow.getWindowTimeWidth() / 2; - long timestampOfCenterPosition = 0; - long timestampOfRightPosition = 0; - - // Let's do the border verifications - if ( timestampOfLeftPosition < histogramContent.getStartTime() ) { - - timestampOfLeftPosition = histogramContent.getStartTime(); - timestampOfCenterPosition = timestampOfLeftPosition + currentWindow.getWindowTimeWidth() / 2; - timestampOfRightPosition = timestampOfLeftPosition + currentWindow.getWindowTimeWidth(); - - } else { - - timestampOfRightPosition = this.getHistogramContent().getClosestElementFromXPosition( newAbsoluteXPosition ).firstIntervalTimestamp + currentWindow.getWindowTimeWidth() / 2; - - if ( timestampOfRightPosition > histogramContent.getEndTime() ) { - - timestampOfRightPosition = histogramContent.getEndTime(); - timestampOfCenterPosition = timestampOfRightPosition - currentWindow.getWindowTimeWidth() / 2; - timestampOfLeftPosition = timestampOfRightPosition - currentWindow.getWindowTimeWidth(); - - } else { - - timestampOfCenterPosition = this.getHistogramContent().getClosestElementFromXPosition( newAbsoluteXPosition ).firstIntervalTimestamp; - - } - - } - - // We will do the update in case of different center timestamp - if( timestampOfCenterPosition != currentWindow.getTimestampOfCenterPosition() ) { - // Firstly we will setup new left, right and center timestamps - currentWindow.setTimestampOfLeftPosition( timestampOfLeftPosition ); - currentWindow.setTimestampOfCenterPosition( timestampOfCenterPosition ); - currentWindow.setTimestampOfRightPosition( timestampOfRightPosition ); - - // After we will update coordonates using timestamps already recalculated - currentWindow.setWindowXPositionLeft( histogramContent.getClosestXPositionFromTimestamp(timestampOfLeftPosition) ); - currentWindow.setWindowXPositionCenter( histogramContent.getClosestXPositionFromTimestamp(timestampOfCenterPosition) ); - currentWindow.setWindowXPositionRight( histogramContent.getClosestXPositionFromTimestamp(timestampOfRightPosition) ); - - redrawAsynchronously(); - } - } - } - - /** - * Function that is called when the selection window is re-centered.<p> - * Note: Given position should be timestamp in the experiment timerange<p> - * - * Recenter the window and notify the HistogramView that the window changed. - * - * @param timestampOfCenterPosition New timestamp of center position. - */ - public void setWindowCenterPosition(long timestampOfCenterPosition) { - - // We will check if the coordinate the same - if ( timestampOfCenterPosition != currentWindow.getTimestampOfCenterPosition() ) { - - long timestampOfLeft = timestampOfCenterPosition - currentWindow.getWindowTimeWidth() / 2; - long timestampOfCenter = 0; - long timestampOfRight = 0; - - int windowXPositionLeft = histogramContent.getClosestXPositionFromTimestamp(timestampOfLeft); - int windowXPositionCenter = 0; - int windowXPositionRight = 0; - - // Let's do the border verifications - if ( timestampOfLeft < histogramContent.getStartTime() ) { - - timestampOfLeft = histogramContent.getStartTime(); - timestampOfCenter = timestampOfLeft + currentWindow.getWindowTimeWidth() / 2; - timestampOfRight = timestampOfLeft + currentWindow.getWindowTimeWidth(); - - windowXPositionLeft = histogramContent.getClosestXPositionFromTimestamp(timestampOfLeft); - windowXPositionCenter = histogramContent.getClosestXPositionFromTimestamp(timestampOfCenter); - windowXPositionRight = histogramContent.getClosestXPositionFromTimestamp(timestampOfRight); - - } else { - - timestampOfRight = timestampOfCenterPosition + currentWindow.getWindowTimeWidth() / 2; - windowXPositionRight = histogramContent.getClosestXPositionFromTimestamp(timestampOfRight); - - if ( timestampOfRight > histogramContent.getEndTime() ) { - - timestampOfRight = histogramContent.getEndTime(); - timestampOfCenter = timestampOfRight - currentWindow.getWindowTimeWidth() / 2; - timestampOfLeft = timestampOfRight - currentWindow.getWindowTimeWidth(); - - windowXPositionLeft = histogramContent.getClosestXPositionFromTimestamp(timestampOfLeft); - windowXPositionCenter = histogramContent.getClosestXPositionFromTimestamp(timestampOfCenter); - windowXPositionRight = histogramContent.getClosestXPositionFromTimestamp(timestampOfRight); - - } else { - - timestampOfCenter = timestampOfCenterPosition; - windowXPositionCenter = histogramContent.getClosestXPositionFromTimestamp(timestampOfCenter); - - } - - } - - // Firstly we will setup new left, right and center timestamps - currentWindow.setTimestampOfLeftPosition( timestampOfLeft ); - currentWindow.setTimestampOfCenterPosition( timestampOfCenter ); - currentWindow.setTimestampOfRightPosition( timestampOfRight ); - - // We will do the update in case of different center timestamp - if( windowXPositionCenter != currentWindow.getWindowXPositionCenter() ) { - - // After we will update coordonates using timestamps already recalculated - currentWindow.setWindowXPositionLeft(windowXPositionLeft); - currentWindow.setWindowXPositionCenter(windowXPositionCenter); - currentWindow.setWindowXPositionRight(windowXPositionRight); - - redrawAsynchronously(); - } - } - } - - - /** - * Function that is called when the selection window size (time width) changed by an absolute time.<p> - * Note: Given time should be in nanoseconds, positive. - * - * Set the new window size and notify the HistogramView that the window changed. - * - * @param newTime New absoulte time (in nanoseconds) to apply to the window. - */ - public void resizeWindowByAbsoluteTime(long newTime) { - if ( newTime != getSelectedWindowSize() ) { - - resizeWindowByAbsoluteTimeWithoutNotification(newTime); - - notifyParentSelectionWindowChangedAsynchronously(); - } - } - - /** - * Function that is called when the selection window size (time width) changed by an absolute time.<p> - * Note: Given time should be in nanoseconds, positive. - * - * Set the new window size and notify the HistogramView that the window changed. - * - * @param newTime New absoulte time (in nanoseconds) to apply to the window. - */ - public void resizeWindowByAbsoluteTimeWithoutNotification(long newTime) { - - // We will change the size in case of delta (newTime) != 0 - if (newTime != 0 ) { - - if(newTime > getHistogramContent().getEndTime() - getHistogramContent().getStartTime()) { - newTime = getHistogramContent().getEndTime() - getHistogramContent().getStartTime(); - } - - setSelectedWindowSize(newTime); - - /* - // Yuriy: we can't use this function because we change the left and right coordinates. - setWindowCenterPosition(currentWindow.getWindowXPositionCenter()); - */ - - long timestampOfLeftPosition = currentWindow.getTimestampOfCenterPosition() - currentWindow.getWindowTimeWidth() / 2; - long timestampOfCenterPosition = currentWindow.getTimestampOfCenterPosition(); - long timestampOfRightPosition = 0; - - // Let's do the border verifications - if ( timestampOfLeftPosition < histogramContent.getStartTime() ) { - - timestampOfLeftPosition = histogramContent.getStartTime(); - timestampOfCenterPosition = timestampOfLeftPosition + currentWindow.getWindowTimeWidth() / 2; - timestampOfRightPosition = timestampOfLeftPosition + currentWindow.getWindowTimeWidth(); - - } else { - - timestampOfRightPosition = currentWindow.getTimestampOfCenterPosition() + currentWindow.getWindowTimeWidth() / 2; - - if ( timestampOfRightPosition > histogramContent.getEndTime() ) { - - timestampOfRightPosition = histogramContent.getEndTime(); - timestampOfCenterPosition = timestampOfRightPosition - currentWindow.getWindowTimeWidth() / 2; - timestampOfLeftPosition = timestampOfRightPosition - currentWindow.getWindowTimeWidth(); - - } - - } - - // Firstly we will setup new left, right and center timestamps - currentWindow.setTimestampOfLeftPosition( timestampOfLeftPosition ); - currentWindow.setTimestampOfCenterPosition( timestampOfCenterPosition ); - currentWindow.setTimestampOfRightPosition( timestampOfRightPosition ); - - // After we will update coordonates using timestamps already recalculated - currentWindow.setWindowXPositionLeft( histogramContent.getClosestXPositionFromTimestamp(timestampOfLeftPosition) ); - currentWindow.setWindowXPositionCenter( histogramContent.getClosestXPositionFromTimestamp(timestampOfCenterPosition) ); - currentWindow.setWindowXPositionRight( histogramContent.getClosestXPositionFromTimestamp(timestampOfRightPosition) ); - - redrawAsynchronously(); - } - } - - /** - * Notify the parent HistogramView that we have updated information.<p> - * This is intended to be called at the end of the request when we know we have up-to-date information. - */ - @Override - public void notifyParentUpdatedInformation() { - getHistogramView().updateFullExperimentInformation(); - } - - /** - * Notify the parent HistogramView that the SelectionWindow changed.<p> - * This is intended to be called when the window move or is resized. - */ - public void notifyParentSelectionWindowChanged() { - // Notify the parent view that something changed - getHistogramView().windowChangedNotification(); - // Send a broadcast to the framework about the window change - getHistogramView().sendTmfRangeSynchSignalBroadcast(); - } - - /** - * Method to call the "Asynchronous NotifyParentSelectionWindowChanged" for this canvas<p> - * This allow safe update UI objects from different threads. - * - */ - public void notifyParentSelectionWindowChangedAsynchronously() { - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( canvasRedrawer == null ) { - canvasRedrawer = new AsyncCanvasRedrawer(this); - } - - asynchronousNotifyParentSelectionWindowChanged(); - } - - /** - * Function to asynchonously notify the parent of the related canvas that the window changed.<p> - * - * Basically, it just run "notifyParentSelectionWindowChanged()" in asyncExec. - * - */ - public void asynchronousNotifyParentSelectionWindowChanged() { - // Ignore update if widget is disposed - if (this.isDisposed()) return; - - Display display = this.getDisplay(); - display.asyncExec(new Runnable() { - @Override - public void run() { - if(!ParentHistogramCanvas.this.isDisposed()) - notifyParentSelectionWindowChanged(); - } - }); - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvasControlListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvasControlListener.java deleted file mode 100644 index ba5e4c6f56..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvasControlListener.java +++ /dev/null @@ -1,67 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009, 2010 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: - * 2010-06-20 Yuriy Vashchuk - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Base class simplification. - *******************************************************************************/ - -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.events.ControlEvent; - -/** - * <b><u>ParentHistogramCanvasControlListener</u></b> - * <p> - * Implementation of a ControlListener for the need of the ParentHistogramCanvas - * <p> - */ -public class ParentHistogramCanvasControlListener extends HistogramCanvasControlListener { - - private ParentHistogramCanvas ourCanvas = null; - - /** - * ParentHistogramCanvasControlListenerl constructor - * - * @param newCanvas Related canvas - */ - public ParentHistogramCanvasControlListener(ParentHistogramCanvas newCanvas) { - ourCanvas = newCanvas; - } - - - /** - * Method called when the canvas is resized.<p> - * - * We need to tell the content that the canvas size changed and to recenter the windows - * - * @param event The control event generated by the resize. - */ - @Override - public void controlResized(ControlEvent event) { - - if ( (ourCanvas != null) && (ourCanvas.getHistogramContent() != null) ) { - int newSize = ourCanvas.getSize().x; - int oldSize = ourCanvas.getHistogramContent().getCanvasWindowSize(); - - // Set the new canvas size - ourCanvas.getHistogramContent().setCanvasWindowSize(newSize); - - // Try to recenter to window at the same place it was - // Note : this is a best hope approach and is not intended to be precise; - // the idea is to avoid issuing a (maybe) long request fo the selection window; - // There WILL be slight discrepancy between the "window values" (timestamp, etc...) showed - // and what it really points to. The user should reclick by himself to refresh it. - int oldWindowCenter = ourCanvas.getCurrentWindow().getWindowXPositionCenter(); - int newWindowCenter = (int)Math.ceil((double)newSize * ((double)oldWindowCenter / (double)oldSize)); - ourCanvas.setWindowCenterPosition(newWindowCenter); - } - } -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvasPaintListener.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvasPaintListener.java deleted file mode 100644 index 63ca7e392b..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/ParentHistogramCanvasPaintListener.java +++ /dev/null @@ -1,289 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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: - * William Bourque - Initial API and implementation - * - * Modifications: - * 2010-07-16 Yuriy Vashchuk - Base class simplification. Redraw bug correction. - * Double Buffering implementation. - *******************************************************************************/ - -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.PaintEvent; - -import org.eclipse.swt.graphics.Color; -import org.eclipse.swt.graphics.GC; -import org.eclipse.swt.graphics.Image; - -/** - * <b><u>HistogramCanvasPaintListener</u></b> - * <p> - * Implementation of a PaintListener for the specific need of the ParentHistogramCanvas. - * <p> - * The difference with the default one is that this one take a content that is the power of 2 higher - * than the display size.<p> - * - * When it is time to draw, it takes the closest power of 2 smaller than the canvas size; it is then easy to - * concatenate the interval as they are both power of 2.<p> - * The difference between the power of 2 and the not-power-of-2 canvas size is then filled by drawing bar that are - * slightly larger every (power/canvasSize) interval.<p> - */ -public class ParentHistogramCanvasPaintListener extends HistogramCanvasPaintListener -{ - private static ParentHistogramCanvas parentCanvas = null; - - /** - * ParentHistogramCanvasPaintListener constructor - * - * @param newCanvas Related canvas - */ - public ParentHistogramCanvasPaintListener(ParentHistogramCanvas newCanvas) { - parentCanvas = newCanvas; - } - - // *** VERIFY *** - // Is it good to put this synchronized? - // - /** - * Draw the histogram bars in the canvas.<p> - * This drawing function expect the content to be the power of 2 higher than the canvas size. - * The bars size will be slightly dynamic to fill the gap between the power and the canvas size.<p> - * - * Note : This draw function is somewhat heavier than the default one. - * - * @param event The generated paint event when redraw is called. - */ - @Override - public synchronized void drawHistogram(GC imageGC, Image image) { - final HistogramContent tmpContent = parentCanvas.getHistogramContent(); - final int tmpBarWidth = tmpContent.getBarsWidth(); - - // Calculate the closest power of 2 just smaller than the canvas size - final int closestPowerToCanvas = (int)Math.pow(2, Math.floor( Math.log( image.getBounds().width ) / Math.log(2.0) )); - - // First clear the whole canvas to have a clean section where to draw - clearDrawingSection(imageGC, image, parentCanvas); - - // Make sure the canvas didn't change size, it which case we need to recalculate our heights - recalculateHeightIfCanvasSizeChanged(); - - // Calculate the factor of difference between canvas and the power - final double factor = (double)image.getBounds().width / (double)closestPowerToCanvas; - // Calculate how many interval will need to be concatenated into one pixel - final int intervalDifference = (tmpContent.getNbElement() / closestPowerToCanvas)*tmpBarWidth; - - // This keep a link between the position in "power" and the pixel we draw - // I.e. correlation between position in the power ("fake" pixels) and the position in the canvas ("real" pixels) - // So if pos == 30 and factor == 1.5, we know that the pixel that draw this pos is (30 * 1.5) == 45 - int posInPower = 0; - int widthFilled = 0; - - // This will be the color for all the bars that wil be draw below. - imageGC.setBackground( new Color( imageGC.getDevice(), 74, 112, 139) ); - - // Read from 0 up to the currently ready position - // We advance by "intervalDifference" as the bars migth not represent 1 interval only - int itemWidth = 0; - int thisElementHeight = 0; - for( int contentPos=0; contentPos < tmpContent.getReadyUpToPosition(); contentPos += intervalDifference ) { - // Width of the current item. - // Vary because of the difference between the power of 2 and the canvas size - // Ex: if power == 1024 and canvas == 1500, a bars every (1024/1500) will have a size of 2 instead of 1. - itemWidth = (int)( Math.ceil((double)(posInPower+1)*factor) - Math.ceil((double)posInPower*factor) ); - itemWidth = itemWidth * tmpBarWidth; - - // Concatenate all the element in the interval - // Ex : if power == 1024 and content == 2048, every (2048/1024)*bars_width will be concatenated - thisElementHeight = 0; - for ( int concatPos=0; concatPos<intervalDifference; concatPos++) { - // Make sure we don't cross the last element available. - if ( contentPos + concatPos < tmpContent.getReadyUpToPosition() ) { - thisElementHeight += tmpContent.getElementByIndex(contentPos + concatPos).intervalHeight; - } - } - - // *** NOTE *** - // Y Position in a canvas is REVERSED, so "0" is on top of the screen and "MAX" is on bottom. - // Not very instinctive, isn't it? - // Draw our rectangle - imageGC.fillRectangle( - widthFilled, - (thisElementHeight > image.getBounds().height ? 0 : image.getBounds().height - thisElementHeight), - itemWidth, - thisElementHeight - ); - - // Keep in a variable how much width we filld so far - widthFilled += itemWidth; - // Keep a correlation between fake_pixel -> real_pixel, - // this is used to calculate the width of each element - posInPower++; - } - } - - /* - * The function will make sure that the "max difference average" factor is still the same as before; - * if not, the heigth of the events will be recalculated.<p> - * - * The factor might change if the canvas is resized by a big factor.<p> - */ - protected void recalculateHeightIfCanvasSizeChanged() { - final HistogramContent tmpContent = parentCanvas.getHistogramContent(); - // We need to ajust the "maxDifferenceToAverageFactor" as the bars we draw might be slitghly larger than the value asked - // Each "interval" are concatenated when draw so the worst case should be : - // contentSize / (closest power of 2 to canvasMaxSize) - // Ex : if canvasSize is 1500 -> (2048 / 1024) == 2 so maxDiff should be twice larger - // - // His is set in the create content of the canvas, but we need to recalculate it - // here because the window might have been resized! - final int exp = (int)Math.floor( Math.log( (double)tmpContent.getCanvasWindowSize() ) / Math.log(2.0) ); - final int contentSize = (int)Math.pow(2, exp); - final double maxBarsDiffFactor = ((double)tmpContent.getNbElement() / (double)contentSize ); - - // Floating point comparaison : - // We consider it is different if the difference is greater than 10^-3 - if ( Math.abs(maxBarsDiffFactor - tmpContent.getMaxDifferenceToAverageFactor()) > 0.001 ) { - // The factor changed! That's unfortunate because it will take a while to recalculate. - tmpContent.setMaxDifferenceToAverageFactor(maxBarsDiffFactor); - tmpContent.recalculateHeightFactor(); - tmpContent.recalculateEventHeight(); - } - } - - /** - * Function called when the canvas need to redraw.<p> - * - * @param event The generated paint event when redraw is called. - */ - private final String DATA_KEY = "double-buffer-image"; //$NON-NLS-1$ - @Override - public void paintControl(PaintEvent event) { - - if (parentCanvas.getSize().x > 0 && parentCanvas.getSize().y > 0) { - Image image = (Image) parentCanvas.getData(DATA_KEY); - - // Creates new image only absolutely necessary. - if (image == null - || image.getBounds().width != parentCanvas.getClientArea().width - || image.getBounds().height != parentCanvas.getClientArea().height) { - - image = new Image( - event.display, - parentCanvas.getClientArea().width, - parentCanvas.getClientArea().height - ); - - parentCanvas.setData(DATA_KEY, image); -// isFinished = false; - } - - // Initializes the graphics context of the image. - GC imageGC = new GC(image); - - // If the content is null or has rady to draw we quit the function here - if ( (parentCanvas.getHistogramContent() != null) - && (parentCanvas.getHistogramContent().getReadyUpToPosition() != 0) ) { - - // Call the function that draw the bars -// if (!isFinished) { - drawHistogram(imageGC, image); -// isFinished = HistogramCanvas.getHistogramView().getDataBackgroundFullRequest().isCompleted(); -// } - - Image img = new Image (image.getDevice(), image, SWT.IMAGE_COPY); - GC imgGC = new GC(img); - - // If we have a selected window set to visible, call the function to draw it - if ( (parentCanvas.getCurrentWindow() != null) && (parentCanvas.getCurrentWindow().getSelectedWindowVisible()) ) { - drawSelectedWindow( - imgGC, - img - ); - } - - // Draws the buffer image onto the canvas. - event.gc.drawImage(img, 0, 0); - - imgGC.dispose(); - img.dispose(); - } - - imageGC.dispose(); - } - - } - - /** - * Draw the selection window in the canvas.<p> - * This draw a square around the selected section with a crosshair in the middle. - * The square cannot be smaller than "MINIMUM_WINDOW_WIDTH" - * - * @param imageGC GC content. - * @param image Image content. - */ - public void drawSelectedWindow(GC imageGC, Image image) { - // Get the window position... this would fail if the window is not initialized yet - final int positionCenter = parentCanvas.getCurrentWindow().getWindowXPositionCenter(); - final int positionLeft = parentCanvas.getCurrentWindow().getWindowXPositionLeft(); - final int positionRight = parentCanvas.getCurrentWindow().getWindowXPositionRight(); - - final int imageHeight = image.getBounds().height; - final int imageHalfHeight = image.getBounds().height / 2; - final int crosshairHalfWidth = HistogramConstant.SELECTION_CROSSHAIR_WIDTH / 2; - final int lineHalfWidth = HistogramConstant.SELECTION_LINE_WIDTH / 2; - - // Draw the crosshair - imageGC.setForeground( new Color (imageGC.getDevice(), 255, 128, 0) ); - imageGC.setLineWidth(HistogramConstant.SELECTION_CROSSHAIR_WIDTH); - imageGC.setLineStyle(SWT.LINE_SOLID); - if(imageHeight > 40) { - imageGC.drawLine( - positionCenter - crosshairHalfWidth, - imageHalfHeight - 20, - positionCenter - crosshairHalfWidth, - imageHalfHeight + 20 - ); - } - if(positionRight - positionLeft > 40) { - imageGC.drawLine( - positionCenter - 20, - imageHalfHeight - crosshairHalfWidth, - positionCenter + 20, - imageHalfHeight - crosshairHalfWidth - ); - } - - // Draw the selection window square - imageGC.setLineWidth(HistogramConstant.SELECTION_LINE_WIDTH); - imageGC.setLineStyle(SWT.LINE_SOLID); - imageGC.drawRoundRectangle( - positionLeft + lineHalfWidth, - lineHalfWidth, - (positionRight - positionLeft) - lineHalfWidth, - imageHeight - HistogramConstant.SELECTION_LINE_WIDTH, - 15, - 15 - ); - - // Show the selection - imageGC.setBackground( new Color (imageGC.getDevice(), 255, 128, 0) ); - imageGC.setAlpha(25); - imageGC.fillRoundRectangle( - positionLeft + 1, - lineHalfWidth + 1, - (positionRight - positionLeft) - lineHalfWidth - 1, - imageHeight - lineHalfWidth - 1, - 15, - 15 - ); - } - -} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/TimeRangeHistogram.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/TimeRangeHistogram.java new file mode 100644 index 0000000000..265e269bed --- /dev/null +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/TimeRangeHistogram.java @@ -0,0 +1,67 @@ +/******************************************************************************* + * Copyright (c) 2011 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 + *******************************************************************************/ + +package org.eclipse.linuxtools.lttng.ui.views.histogram; + +import org.eclipse.swt.widgets.Composite; + +/** + * <b><u>TimeRangeHistogram</u></b> + * <p> + * A basic histogram with the following additional features: + * <ul> + * <li>zoom in: mouse wheel up (or forward) + * <li>zoom out: mouse wheel down (or backward) + * </ul> + */ +public class TimeRangeHistogram extends Histogram { + + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + + HistogramZoom fZoom; + + // ------------------------------------------------------------------------ + // Constructor + // ------------------------------------------------------------------------ + + public TimeRangeHistogram(HistogramView view, Composite parent) { + super(view, parent); + fZoom = new HistogramZoom(this, fCanvas, getStartTime(), getTimeLimit()); + } + + // ------------------------------------------------------------------------ + // Operations + // ------------------------------------------------------------------------ + + @Override + public void updateTimeRange(long startTime, long endTime) { + ((HistogramView) fParentView).updateTimeRange(startTime, endTime); + } + + @Override + public synchronized void clear() { + if (fZoom != null) + fZoom.stop(); + super.clear(); + } + + public synchronized void setTimeRange(long startTime, long duration) { + fZoom.setNewRange(startTime, duration); + } + + public void setFullRange(long startTime, long endTime) { + fZoom.setFullRange(startTime, endTime); + } + +} diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/TimeTextGroup.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/TimeTextGroup.java deleted file mode 100644 index 3d760d0b54..0000000000 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/TimeTextGroup.java +++ /dev/null @@ -1,506 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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 - *******************************************************************************/ - -package org.eclipse.linuxtools.lttng.ui.views.histogram; - -import org.eclipse.swt.SWT; -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.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Group; -import org.eclipse.swt.widgets.Label; -import org.eclipse.swt.widgets.Text; - -/** - * <b><u>TimeTextGroup</u></b> - * <p> - * Special control for HistogramView - * <p> - * This control will give you a group, a text box and a label at once. - */ -public class TimeTextGroup implements FocusListener, KeyListener { - -/* - // 2010-06-10 Yuriy: Has been moved to header into HistogramView.java - protected static final String NANOSEC_LABEL = "sec"; -*/ - private static final String LONGEST_STRING_VALUE = "." + Long.MAX_VALUE; //$NON-NLS-1$ - private static final int MAX_CHAR_IN_TEXTBOX = LONGEST_STRING_VALUE.length(); - - // The "small font" height used to display time will be "default font" minus this constant - private static final int VERY_SMALL_FONT_MODIFIER = 2; - private static final int SMALL_FONT_MODIFIER = 1; - - // Indentation size -// private static final int DEFAULT_INDENT_SIZE = 10; - - private HistogramView parentView = null; - private AsyncTimeTextGroupRedrawer asyncRedrawer = null; - - private Group grpName = null; - private Text txtNanosec = null; - private Label lblNanosec = null; - - private long timeValue = 0L; - - /** - * Default Constructor.<p> - * - * @param newParentView Parent HistogramView - * @param parent Parent Composite, used to position the inner controls. - * @param textStyle Style of the textbox. Usually SWT.BORDER or SWT.NONE (or anything that suit a Text) - * @param groupStyle Style of the group. Anything that suite a Text - */ - public TimeTextGroup(HistogramView newParentView, Composite parent, int textStyle, int groupStyle) { - this(newParentView, parent, textStyle, groupStyle, "", HistogramConstant.formatNanoSecondsTime(0L), false); //$NON-NLS-1$ - } - - /** - * Default Constructor with adjustement for small screen.<p> - * - * @param newParentView Parent HistogramView - * @param parent Parent Composite, used to position the inner controls. - * @param textStyle Style of the textbox. Usually SWT.BORDER or SWT.NONE (or anything that suit a Text) - * @param groupStyle Style of the group. Anything that suite a Text - * @param isSpaceSaverNeeded Value that tell if we try to save some space in the control. - */ - public TimeTextGroup(HistogramView newParentView, Composite parent, int textStyle, int groupStyle, boolean isSpaceSaverNeeded) { - this(newParentView, parent, textStyle, groupStyle, "", HistogramConstant.formatNanoSecondsTime(0L), isSpaceSaverNeeded); //$NON-NLS-1$ - } - - /** - * Default Constructor, allow you to give the groupname and the textbox value.<p> - * - * @param newParentView Parent HistogramView - * @param parent Parent Composite, used to position the inner controls. - * @param textStyle Style of the textbox. Usually SWT.BORDER or SWT.NONE (or anything that suit a Text) - * @param groupStyle Style of the group. Anything that suite a Text - * @param groupValue Value (label) of the group. - * @param textValue Value of the textbox. - */ - public TimeTextGroup(HistogramView newParentView, Composite parent, int textStyle, int groupStyle, String groupValue, String textValue) { - this(newParentView, parent, textStyle, groupStyle, groupValue, textValue, false); - } - - /** - * Default Constructor with adjustment for small screen, allow you to give the group name and the text box value.<p> - * - * @param newParentView Parent HistogramView - * @param parent Parent Composite, used to position the inner controls. - * @param textStyle Style of the text box. Usually SWT.BORDER or SWT.NONE (or anything that suit a Text) - * @param groupStyle Style of the group. Anything that suite a Text - * @param groupValue Value (label) of the group. - * @param textValue Value of the text box. - * @param isSpaceSaverNeeded Value that tell if we try to save some space in the control. - */ - public TimeTextGroup(HistogramView newParentView, Composite parent, int textStyle, int groupStyle, String groupValue, String textValue, boolean isSpaceSaverNeeded) { - Font font = parent.getFont(); - FontData tmpFontData = font.getFontData()[0]; - - Font smallFont = null; - int textBoxSize = -1; -// int indentSize = -1; - - // If we were asked to save size, calculate the correct value here - if ( isSpaceSaverNeeded == true ) { - smallFont = new Font(font.getDevice(), tmpFontData.getName(), tmpFontData.getHeight()-VERY_SMALL_FONT_MODIFIER, tmpFontData.getStyle()); - - // No minimum textBoxSize and no indent size - textBoxSize = 0; -// indentSize = 0; - } - else { - // We use only a slightly smaller font - smallFont = new Font(font.getDevice(), tmpFontData.getName(), tmpFontData.getHeight()-SMALL_FONT_MODIFIER, tmpFontData.getStyle()); - - // ** Creation of the textbox - // Calculate the optimal size of the textbox already - // This will avoid the control to move around and resize when bigger value are given - textBoxSize = HistogramConstant.getTextSizeInControl(parent, LONGEST_STRING_VALUE); - - // Default indent -// indentSize = DEFAULT_INDENT_SIZE; - } - - parentView = newParentView; - - // ** Creation of the group -// GridLayout gridLayoutgroup = new GridLayout(2, false); - GridLayout gridLayoutgroup = new GridLayout(1, false); - gridLayoutgroup.horizontalSpacing = 0; - gridLayoutgroup.verticalSpacing = 0; - grpName = new Group(parent, groupStyle); - grpName.setText(groupValue); - grpName.setFont(smallFont); - grpName.setLayout(gridLayoutgroup); - - txtNanosec = new Text(grpName, textStyle); - txtNanosec.setTextLimit( MAX_CHAR_IN_TEXTBOX ); - txtNanosec.setText(textValue); - txtNanosec.setFont(smallFont); - GridData gridDataTextBox = new GridData(SWT.LEFT, SWT.CENTER, true, false); - gridDataTextBox.horizontalIndent = 0; // indentSize; - gridDataTextBox.verticalIndent = 0; - gridDataTextBox.minimumWidth = textBoxSize; - txtNanosec.setLayoutData(gridDataTextBox); - - // ** Creation of the label -/* - lblNanosec = new Label(grpName, SWT.LEFT); - lblNanosec.setText(NANOSEC_LABEL); - lblNanosec.setFont(smallFont); - GridData gridDataLabel = new GridData(SWT.LEFT, SWT.CENTER, false, false); - gridDataLabel.horizontalIndent = indentSize; - gridDataLabel.verticalIndent = 0; - lblNanosec.setLayoutData(gridDataLabel); -*/ - - // Add all listener - addNeededListeners(); - } - - /* - * Create and add all listeners needed by our control.<p> - */ - protected void addNeededListeners() { - - // AsyncCanvasRedrawer is an internal class - // This is used to redraw the canvas without danger from a different thread - asyncRedrawer = new AsyncTimeTextGroupRedrawer(this); - - txtNanosec.addFocusListener(this); - txtNanosec.addKeyListener(this); - } - - /** - * Getter for the layout data currently in use.<p> - * - * @return the layout - */ - public Object getLayoutData() { - return grpName.getLayoutData(); - } - - /** - * Set a new layoutData for our control.<p> - * - * @param layoutData the new layout data - */ - public void setLayoutData(Object layoutData) { - grpName.setLayoutData(layoutData); - } - - /** - * Get the control's parent.<p> - * - * @return Currently used parent - */ - public Composite getParent() { - return grpName.getParent(); - } - - /** - * Set a new parent for the control.<p> - * - * @return Currently used parent - */ - public void setParent(Composite newParent) { - grpName.setParent(newParent); - txtNanosec.setParent(newParent); - lblNanosec.setParent(newParent); - } - - - public boolean isDisposed() { - return grpName.isDisposed(); - } - - /** - * Getter for the time value of the control.<p> - * - * @return The nanoseconds time value - */ - public long getValue() { - return timeValue; - } - - /** - * Set a new String value to the control.<p> - * Note : The String value will be converted in long before being applied; - * if any conversion error occur, 0 will be used. <p> - * - * @param newTimeAsString The value to convert and set. - */ - public void setValue(String newTimeAsString) { - long timeAsLong = HistogramConstant.convertStringToNanoseconds(newTimeAsString); - setValue( timeAsLong ); - } - - /** - * Set a new value to the control.<p> - * Note : The value will be formatted as nanosecond value, - * missing zero will be added if needed.<p> - * - * @param newTime The value to set. - */ - public void setValue(long newTime) { - timeValue = newTime; - txtNanosec.setText( HistogramConstant.formatNanoSecondsTime(newTime) ); - } - - /** - * Set a new String value, asynchronously.<p> - * This will call setValue(String) in async.Exec to avoid Thread Access problem to UI.<p> - * - * @param newTimeAsString The value to convert and set. - */ - public void setValueAsynchronously(String newTimeAsString) { - long timeAsLong = HistogramConstant.convertStringToNanoseconds(newTimeAsString); - setValueAsynchronously( timeAsLong ); - } - - /** - * Set a new String value, asynchronously.<p> - * This will call setValue(long) in async.Exec to avoid Thread Access problem to UI.<p> - * - * @param newTimeAsString The value to set. - */ - public void setValueAsynchronously(long newTime) { - // Set the correct value ASAP - timeValue = newTime; - - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( asyncRedrawer == null ) { - asyncRedrawer = new AsyncTimeTextGroupRedrawer(this); - } - - asyncRedrawer.asynchronousSetValue(newTime); - } - - /** - * Set a new group name (label) for this control.<p> - * - * @param newName The new name to set. - */ - public void setGroupName(String newName) { - grpName.setText(newName); - } - - /** - * Set a new group name (label) for this control, asynchronously.<p> - * This will call setValue(long) in async.Exec to avoid Thread Access problem to UI.<p> - * - * @param newName The new name to set. - */ - public void setGroupNameAsynchronously(String newGroupName) { - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( asyncRedrawer == null ) { - asyncRedrawer = new AsyncTimeTextGroupRedrawer(this); - } - - asyncRedrawer.asynchronousSetGroupName(newGroupName); - } - - - /** - * Method to call the "Asynchronous redrawer" for this time text group<p> - * This allow safe redraw from different threads. - */ - public void redrawAsynchronously() { - // Create a new redrawer in case it doesn't exist yet (we never know with thread!) - if ( asyncRedrawer == null ) { - asyncRedrawer = new AsyncTimeTextGroupRedrawer(this); - } - - asyncRedrawer.asynchronousRedraw(); - } - - /** - * Redraw the control - */ - public void redraw () { - grpName.redraw(); - txtNanosec.redraw(); - lblNanosec.redraw(); - } - - /* - * This function is called when an user enter a new string in the control by hand.<p> - * It will ensure the format of the String is valid. - */ - protected void handleNewStringValue() { - String valueInText = txtNanosec.getText(); - long valueAsLong = HistogramConstant.convertStringToNanoseconds(valueInText); - - if ( getValue() != valueAsLong ) { - setValue(valueAsLong); - // Notify our parent that the control was updated - notifyParentUpdatedTextGroupValue(); - } - } - - /** - * This function notify our parent HistogramView that our value changed. - */ - public void notifyParentUpdatedTextGroupValue() { - parentView.timeTextGroupChangeNotification(); - } - - /** - * Function that is called when the canvas get focus.<p> - * - * Doesn't do anything yet... - * - * @param event The focus event generated. - */ - @Override - public void focusGained(FocusEvent event) { - // Nothing to do yet - } - - /** - * Function that is called when the canvas loose focus.<p> - * It will validate that the String entered by the user (if any) is valid.<p> - * - * @param event The focus event generated. - */ - @Override - public void focusLost(FocusEvent event) { - handleNewStringValue(); - } - - /** - * Function that is called when a key is pressed.<p> - * Possible actions : - * - Enter (CR) : Validate the entered String.<p> - * - * @param event The KeyEvent generated when the key was pressed. - */ - @Override - public void keyPressed(KeyEvent event) { - switch (event.keyCode) { - // SWT.CR is "ENTER" Key - case SWT.CR: - handleNewStringValue(); - break; - default: - break; - } - } - - /** - * Function that is called when a key is released.<p> - * Possible actions : - * Nothing yet - * - * @param event The KeyEvent generated when the key was pressed. - */ - @Override - public void keyReleased(KeyEvent e) { - - } -} - -/** - * <b><u>AsyncTimeTextGroupRedrawer Inner Class</u></b> - * <p> - * Asynchronous redrawer for the TimeTextGroup - * <p> - * This class role is to call method that update the UI on asynchronously. - * This should prevent any "invalid thread access" exception when trying to update UI from a different thread. - */ -class AsyncTimeTextGroupRedrawer { - - private TimeTextGroup parentTimeTextGroup = null; - - /** - * AsyncTimeTextGroupRedrawer constructor. - * - * @param newParent Related time text group. - */ - public AsyncTimeTextGroupRedrawer(TimeTextGroup newParent) { - parentTimeTextGroup = newParent; - } - - /** - * Asynchronous SetValue for time text group. - * - * Basically, it just run "getParent().setValue(time)" in asyncExec. - * - * @param newTime The new time to set - */ - public void asynchronousSetValue(final long newTime) { - // Ignore setting of value if widget is disposed - if (parentTimeTextGroup.isDisposed()) return; - - Display display = parentTimeTextGroup.getParent().getDisplay(); - display.asyncExec(new Runnable() { - @Override - public void run() { - if (!parentTimeTextGroup.isDisposed()) { - parentTimeTextGroup.setValue(newTime); - } - } - }); - } - - /** - * Asynchronous SetGroupName for time text group. - * - * Basically, it just run "getParent().setGroupName(name)" in asyncExec. - * - * @param newGroupName The new group name to set - */ - public void asynchronousSetGroupName(String newGroupName) { - // Ignore setting of name if widget is disposed - if (parentTimeTextGroup.isDisposed()) return; - - final String tmpName = newGroupName; - Display display = parentTimeTextGroup.getParent().getDisplay(); - display.asyncExec(new Runnable() { - @Override - public void run() { - if (!parentTimeTextGroup.isDisposed()) { - parentTimeTextGroup.setGroupName(tmpName); - } - } - }); - } - - /** - * Function to redraw the related time text group asynchonously.<p> - * - * Basically, it just run "getParent().redraw()" in asyncExec. - * - */ - public void asynchronousRedraw() { - // Ignore redraw if widget is disposed - if (parentTimeTextGroup.isDisposed()) return; - - Display display = parentTimeTextGroup.getParent().getDisplay(); - display.asyncExec(new Runnable() { - @Override - public void run() { - if (!parentTimeTextGroup.isDisposed()) { - parentTimeTextGroup.getParent().redraw(); - } - } - }); - } -}
\ No newline at end of file diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/messages.properties b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/messages.properties index f6d232292b..2078673bfe 100644 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/messages.properties +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/messages.properties @@ -1,3 +1,2 @@ HistogramView_currentEventLabel=Current Event (sec) -HistogramView_windowCenterLabel=Window Center (sec) HistogramView_windowSpanLabel=Window Span (sec) diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/dialogs/ImportTraceWizardPage.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/dialogs/ImportTraceWizardPage.java index 36670ef2c7..ba8e2999c9 100644 --- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/dialogs/ImportTraceWizardPage.java +++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/dialogs/ImportTraceWizardPage.java @@ -13,7 +13,7 @@ package org.eclipse.linuxtools.lttng.ui.views.project.dialogs; import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.linuxtools.lttng.LttngException; +import org.eclipse.linuxtools.lttng.exceptions.LttngException; import org.eclipse.linuxtools.lttng.trace.LTTngTraceVersion; import org.eclipse.linuxtools.lttng.ui.views.project.handlers.TraceErrorHandler; import org.eclipse.linuxtools.lttng.ui.views.project.model.LTTngProjectNode; |