--- /dev/null	2019-10-22 08:32:25.223037312 -0400
+++ new/application/org.openjdk.jmc.ui/src/main/java/org/openjdk/jmc/ui/misc/ChartDisplayControlBar.java	2019-10-22 09:27:33.182317385 -0400
@@ -0,0 +1,527 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, Red Hat Inc. All rights reserved.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The contents of this file are subject to the terms of either the Universal Permissive License
+ * v 1.0 as shown at http://oss.oracle.com/licenses/upl
+ *
+ * or the following license:
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted
+ * provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of conditions
+ * and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+ * conditions and the following disclaimer in the documentation and/or other materials provided with
+ * the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+ * endorse or promote products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.openjdk.jmc.ui.misc;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.ScrolledComposite;
+import org.eclipse.swt.events.MouseAdapter;
+import org.eclipse.swt.events.MouseEvent;
+import org.eclipse.swt.events.MouseMoveListener;
+import org.eclipse.swt.events.MouseWheelListener;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.events.PaintListener;
+import org.eclipse.swt.graphics.Cursor;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Canvas;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Scale;
+import org.eclipse.swt.widgets.Text;
+import org.openjdk.jmc.common.unit.IQuantity;
+import org.openjdk.jmc.common.unit.IRange;
+import org.openjdk.jmc.ui.UIPlugin;
+import org.openjdk.jmc.ui.charts.SubdividedQuantityRange;
+import org.openjdk.jmc.ui.charts.XYChart;
+import org.openjdk.jmc.ui.misc.PatternFly.Palette;
+
+public class ChartDisplayControlBar extends Composite {
+	private static final String ZOOM_IN_CURSOR = "zoomInCursor";
+	private static final String ZOOM_OUT_CURSOR = "zoomOutCursor";
+	private static final String DEFAULT_CURSOR = "defaultCursor";
+	private static final String HAND_CURSOR = "handCursor";
+	private static final int ZOOM_AMOUNT = 1;
+	private Map<String, Cursor> cursors;
+	private Scale scale;
+	private Text zoomText;
+	private XYChart chart;
+	private ChartCanvas chartCanvas;
+	private ChartTextCanvas textCanvas;
+	private List<Button> buttonGroup;
+	private Button zoomInBtn;
+	private Button zoomOutBtn;
+	private Button selectionBtn;
+	private Button zoomPanBtn;
+	private Button scaleToFitBtn;
+	private ZoomPan zoomPan;
+
+	public ChartDisplayControlBar(Composite parent) {
+		super(parent, SWT.NO_BACKGROUND);
+
+		this.setLayout(new GridLayout());
+		this.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true));
+		this.setBackground(Palette.PF_BLACK_300.getSWTColor());
+
+		cursors = new HashMap<>();
+		cursors.put(DEFAULT_CURSOR, getDisplay().getSystemCursor(SWT.CURSOR_ARROW));
+		cursors.put(HAND_CURSOR, getDisplay().getSystemCursor(SWT.CURSOR_HAND));
+		cursors.put(ZOOM_IN_CURSOR, new Cursor(getDisplay(),
+				UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_ZOOM_IN).getImageData(), 0, 0));
+		cursors.put(ZOOM_OUT_CURSOR, new Cursor(getDisplay(),
+				UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_ZOOM_OUT).getImageData(), 0, 0));
+
+		buttonGroup = new ArrayList<>();
+		selectionBtn = new Button(this, SWT.TOGGLE);
+		selectionBtn.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
+		selectionBtn.setImage(UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_SELECTION));
+		selectionBtn.setSelection(true);
+		selectionBtn.addListener(SWT.Selection, new Listener() {
+			@Override
+			public void handleEvent(Event event) {
+				setButtonSelectionStates(selectionBtn, null);
+				changeCursor(DEFAULT_CURSOR);
+			};
+		});
+		buttonGroup.add(selectionBtn);
+
+		zoomInBtn = new Button(this, SWT.TOGGLE);
+		zoomInBtn.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
+		zoomInBtn.setImage(UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_ZOOM_IN));
+		zoomInBtn.setSelection(false);
+		zoomInBtn.addListener(SWT.Selection,  new Listener() {
+			@Override
+			public void handleEvent(Event event) {
+				if (scale.getSelection() > 0) {
+					setButtonSelectionStates(zoomInBtn, zoomPanBtn);
+					changeCursor(ZOOM_IN_CURSOR);
+				} else {
+					setButtonSelectionStates(selectionBtn, null);
+					changeCursor(DEFAULT_CURSOR);
+				}
+			}
+		});
+		zoomInBtn.addMouseListener(new LongPressListener(ZOOM_AMOUNT));
+		buttonGroup.add(zoomInBtn);
+
+		scale = new Scale(this, SWT.VERTICAL);
+		scale.setMinimum(0);
+		scale.setMaximum(30);
+		scale.setIncrement(1);
+		scale.setSelection(30);
+		scale.setLayoutData(new GridData(SWT.CENTER, SWT.FILL, true, true));
+		scale.setEnabled(false);
+
+		zoomText = new Text(this, SWT.BORDER | SWT.READ_ONLY | SWT.SINGLE);
+		zoomText.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
+		setZoomPercentageText(100);
+
+		zoomOutBtn = new Button(this, SWT.TOGGLE);
+		zoomOutBtn.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
+		zoomOutBtn.setImage(UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_ZOOM_OUT));
+		zoomOutBtn.setSelection(false);
+		zoomOutBtn.addListener(SWT.Selection,  new Listener() {
+			@Override
+			public void handleEvent(Event e) {
+				if (scale.getSelection() < scale.getMaximum()) {
+					setButtonSelectionStates(zoomOutBtn, zoomPanBtn);
+					changeCursor(ZOOM_OUT_CURSOR);
+				} else {
+					setButtonSelectionStates(selectionBtn, null);
+					changeCursor(DEFAULT_CURSOR);
+				}
+			}
+		});
+		zoomOutBtn.addMouseListener(new LongPressListener(-ZOOM_AMOUNT));
+		buttonGroup.add(zoomOutBtn);
+
+		zoomPanBtn = new Button(this, SWT.TOGGLE);
+		zoomPanBtn.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
+		zoomPanBtn.setImage(UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_ZOOM_PAN));
+		zoomPanBtn.setSelection(false);
+		zoomPanBtn.addListener(SWT.Selection, new Listener() {
+			@Override
+			public void handleEvent(Event event) {
+				showZoomPanDisplay(zoomPanBtn.getSelection());
+			}
+		});
+		buttonGroup.add(zoomPanBtn);
+
+		scaleToFitBtn = new Button(this, SWT.PUSH);
+		scaleToFitBtn.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));
+		scaleToFitBtn.setImage(UIPlugin.getDefault().getImage(UIPlugin.ICON_FA_SCALE_TO_FIT));
+		scaleToFitBtn.setSelection(false);
+		scaleToFitBtn.addListener(SWT.Selection, new Listener() {
+			@Override
+			public void handleEvent(Event event) {
+				resetZoomScale();
+				chart.resetTimeline();
+				chartCanvas.redrawChart();
+			}
+		});
+		buttonGroup.add(scaleToFitBtn);
+	}
+
+	public void setChart(XYChart chart) {
+		this.chart = chart;
+	}
+
+	public void setChartCanvas(ChartCanvas chartCanvas) {
+		this.chartCanvas = chartCanvas;
+	}
+
+	public void setTextCanvas(ChartTextCanvas textCanvas) {
+		this.textCanvas = textCanvas;
+	}
+
+	public void zoomOnClick(Boolean mouseDown) {
+		boolean shouldZoom = zoomInBtn.getSelection() || zoomOutBtn.getSelection() ;
+		if (shouldZoom) {
+			if (mouseDown) {
+				chart.clearSelection();
+			} else {
+				int zoomAmount = zoomInBtn.getSelection() ? ZOOM_AMOUNT : -ZOOM_AMOUNT;
+				zoom(zoomAmount);
+				if (textCanvas != null) {
+					textCanvas.redrawChartText();
+				}
+			}
+		}
+	}
+
+	public void zoomToSelection() {
+		if (zoomInBtn.getSelection()) {
+			IQuantity selectionStart = chart.getSelectionStart();
+			IQuantity selectionEnd = chart.getSelectionEnd();
+			if (selectionStart == null || selectionEnd == null) {
+				chart.clearVisibleRange();
+			} else {
+				chart.setVisibleRange(selectionStart, selectionEnd);
+				chartCanvas.redrawChart();
+			}
+		}
+	}
+
+	public void setZoomPercentageText(double zoom) {
+		zoomText.setText(String.format("%.2f %s", zoom, "%"));
+	}
+
+	public void setScaleValue(int value) {
+		scale.setSelection(scale.getMaximum() - value);
+	}
+
+	public void increaseScaleValue() {
+		scale.setSelection(scale.getSelection() - 1);
+	}
+
+	public void decreaseScaleValue() {
+		scale.setSelection(scale.getSelection() + 1);
+	}
+
+	public void resetZoomScale() {
+		scale.setSelection(scale.getMaximum());
+		setZoomPercentageText(100);
+	}
+
+	private void changeCursor(String cursorName) {
+		chartCanvas.changeCursor(cursors.get(cursorName));
+	}
+
+	private void setButtonSelectionStates(Button buttonSelected, Button dependentButton) {
+		for (Button button : buttonGroup) {
+			if ((button.getStyle() & SWT.TOGGLE) != 0) {
+				if (button.equals(buttonSelected)) {
+					button.setSelection(true);
+				} else if (dependentButton != null ) {
+					if (button.equals(dependentButton)) {
+						button.setSelection(true);
+					} else {
+						button.setSelection(false);
+					}
+				} else {
+					button.setSelection(false);
+				}
+			}
+			showZoomPanDisplay(zoomPanBtn.getSelection());
+		}
+	}
+
+	private class LongPressListener extends MouseAdapter {
+
+		private static final long LONG_PRESS_TIME = 500;
+		private Timer timer;
+		private int zoomAmount;
+
+		LongPressListener(int zoomAmount) {
+			this.zoomAmount = zoomAmount;
+		}
+
+		@Override
+		public void mouseDown(MouseEvent e) {
+			if(e.button == 1) {
+				timer = new Timer();
+				timer.schedule(new LongPress(), LONG_PRESS_TIME, (long) (LONG_PRESS_TIME * 1.5));
+			}
+		}
+
+		@Override
+		public void mouseUp(MouseEvent e) {
+			timer.cancel();
+		}
+
+		public class LongPress extends TimerTask {
+
+			@Override
+			public void run() {
+				doZoomInOut(zoomAmount);
+			}
+		}
+
+		private void doZoomInOut(int zoomAmount) {
+			DisplayToolkit.inDisplayThread().execute( () -> zoom(zoomAmount));
+		}
+	}
+
+	private void zoom(int zoomAmount) {
+		int newScaleValue = scale.getSelection() - zoomAmount;
+		if (newScaleValue >= scale.getMinimum() && newScaleValue <= scale.getMaximum()) {
+			scale.setSelection(scale.getSelection() - zoomAmount);
+			chart.zoom(zoomAmount);
+			chartCanvas.redrawChart();
+		}
+	}
+
+	public void createZoomPan(Composite parent) {
+		zoomPan = new ZoomPan(parent);
+		parent.setVisible(false);
+	}
+
+	private void showZoomPanDisplay(boolean show) {
+		if(show) {
+			zoomPan.getParent().setVisible(true);
+			zoomPan.redrawZoomPan();
+		} else {
+			zoomPan.getParent().setVisible(false);
+		}
+	}
+
+	private class ZoomPan extends Canvas  {
+		private static final int BORDER_PADDING = 2;
+		private IRange<IQuantity> chartRange;
+		private IRange<IQuantity> lastChartZoomedRange;
+		private Rectangle zoomRect;
+
+		public ZoomPan(Composite parent) {
+			super(parent, SWT.NO_BACKGROUND);
+			addPaintListener(new Painter());
+			PanDetector panDetector = new PanDetector();
+			addMouseListener(panDetector);
+			addMouseMoveListener(panDetector);
+			addMouseWheelListener(panDetector);
+			chartRange = chart.getVisibleRange();
+		}
+
+		public void redrawZoomPan() {
+			redraw();
+		}
+
+		private class PanDetector extends MouseAdapter implements MouseMoveListener, MouseWheelListener {
+			Point currentSelection;
+			Point lastSelection;
+			boolean isPan = false;
+
+			@Override
+			public void mouseDown(MouseEvent e) {
+				if (e.button == 1 && zoomRect.contains(e.x, e.y)) {
+					isPan = true;
+					chart.setIsZoomPanDrag(isPan);
+					currentSelection = chartCanvas.translateDisplayToImageCoordinates(e.x, e.y);
+				}
+			}
+
+			@Override
+			public void mouseUp(MouseEvent e) {
+				isPan = false;
+				chart.setIsZoomPanDrag(isPan);
+			}
+
+			@Override
+			public void mouseMove(MouseEvent e) {
+				zoomPan.setCursor(cursors.get(HAND_CURSOR));
+				if (isPan && getParent().getSize().x >= e.x && getParent().getSize().y >= e.y ) {
+					lastSelection = currentSelection;
+					currentSelection = chartCanvas.translateDisplayToImageCoordinates(e.x, e.y);
+					int xdiff = currentSelection.x - lastSelection.x;
+					int ydiff = currentSelection.y - lastSelection.y;
+					updateZoomRectFromPan(xdiff, ydiff);
+				}
+			}
+
+			@Override
+			public void mouseScrolled(MouseEvent e) {
+				updateZoomRectFromPan(0, -e.count);
+			}
+		}
+
+		private void updateZoomRectFromPan(int xdiff, int ydiff) {
+			Point bounds = getParent().getSize();
+			boolean xModified = false;
+			boolean yModified = false;
+
+			int xOld = zoomRect.x;
+			zoomRect.x += xdiff;
+			if (zoomRect.x > (bounds.x - zoomRect.width - BORDER_PADDING - 1))  {
+				zoomRect.x = bounds.x - zoomRect.width - BORDER_PADDING - 1;
+			} else if (zoomRect.x < BORDER_PADDING ) {
+				zoomRect.x = BORDER_PADDING;
+			}
+			xModified = xOld != zoomRect.x;
+
+			int yOld = zoomRect.y;
+			zoomRect.y += ydiff;
+			if (zoomRect.y < BORDER_PADDING ) {
+				zoomRect.y = BORDER_PADDING;
+			} else if (zoomRect.y > (bounds.y - zoomRect.height- BORDER_PADDING - 1))  {
+				zoomRect.y = bounds.y - zoomRect.height - BORDER_PADDING - 1;
+			}
+			yModified = yOld != zoomRect.y;
+
+			if (xModified || yModified) {
+				updateChartFromZoomRect(xModified, yModified);
+				chartCanvas.redrawChart();
+			}
+		}
+
+		private void updateChartFromZoomRect(boolean updateXRange, boolean updateYRange) {
+			Rectangle zoomCanvasBounds = new Rectangle(0, 0, getParent().getSize().x, getParent().getSize().y);
+			Rectangle totalBounds = chartCanvas.getBounds();
+
+			if (updateXRange) {
+				double ratio = getVisibilityRatio(zoomRect.x - BORDER_PADDING,
+						zoomCanvasBounds.x, zoomCanvasBounds.width - BORDER_PADDING);
+				int start = getPixelLocation(ratio, totalBounds.width, 0);
+
+				ratio = getVisibilityRatio(zoomRect.x + zoomRect.width + BORDER_PADDING + 1,
+						zoomCanvasBounds.width, zoomCanvasBounds.width - BORDER_PADDING);
+				int end = getPixelLocation(ratio, totalBounds.width, totalBounds.width);
+
+				SubdividedQuantityRange xAxis = new SubdividedQuantityRange(chartRange.getStart(),
+						chartRange.getEnd(), totalBounds.width, 1);
+				chart.setVisibleRange(xAxis.getQuantityAtPixel(start), xAxis.getQuantityAtPixel(end));
+				lastChartZoomedRange = chart.getVisibleRange();
+			}
+			if (updateYRange) {
+				double ratio = getVisibilityRatio(zoomRect.y - BORDER_PADDING, 0,
+						zoomCanvasBounds.height - BORDER_PADDING);
+				int top = getPixelLocation(ratio, totalBounds.height, 0);
+
+				Point p = ((ScrolledComposite) chartCanvas.getParent()).getOrigin();
+				p.y = top;
+
+				if (textCanvas != null) {
+					textCanvas.syncScroll(p);
+				}
+				chartCanvas.syncScroll(p);
+			}
+		}
+
+		class Painter implements PaintListener {
+			@Override
+			public void paintControl(PaintEvent e) {
+
+				Rectangle backgroundRect = new Rectangle(0, 0, getParent().getSize().x, getParent().getSize().y);
+				GC gc = e.gc;
+
+				gc.setBackground(Palette.PF_BLACK_400.getSWTColor());
+				gc.fillRectangle(backgroundRect);
+				gc.setForeground(Palette.PF_BLACK_900.getSWTColor());
+				gc.drawRectangle(0, 0, backgroundRect.width - 1 , backgroundRect.height - 1);
+
+				updateZoomRectFromChart();
+
+				gc.setBackground(Palette.PF_BLACK_100.getSWTColor());
+				gc.fillRectangle(zoomRect);
+				gc.setForeground(Palette.PF_BLACK_900.getSWTColor());
+				gc.drawRectangle(zoomRect);
+			}
+		}
+
+		private void updateZoomRectFromChart() {
+			Rectangle zoomCanvasBounds = new Rectangle(0, 0, getParent().getSize().x, getParent().getSize().y);
+			IRange<IQuantity> zoomedRange = chart.getVisibleRange();
+			IQuantity visibleWidth = chartRange.getExtent();
+			double visibleHeight =  chartCanvas.getParent().getBounds().height;
+			Rectangle totalBounds = chartCanvas.getBounds();
+
+			if (zoomRect == null ) {
+				zoomRect = new Rectangle(0, 0, 0, 0);
+			}
+			if (!chart.getVisibleRange().equals(lastChartZoomedRange)) {
+				double ratio = getVisibilityRatio(zoomedRange.getStart(), chartRange.getStart(), visibleWidth);
+				int start = getPixelLocation(ratio, zoomCanvasBounds.width, 0);
+
+				ratio = getVisibilityRatio(zoomedRange.getEnd(), chartRange.getEnd(), visibleWidth);
+				int end = getPixelLocation(ratio, zoomCanvasBounds.width, zoomCanvasBounds.width);
+
+				zoomRect.x = start + BORDER_PADDING;
+				zoomRect.width = end - start - 2 * BORDER_PADDING - 1;
+				lastChartZoomedRange = chart.getVisibleRange();
+			}
+			double ratio = getVisibilityRatio(0, totalBounds.y, totalBounds.height);
+			int top = getPixelLocation(ratio, zoomCanvasBounds.height, 0);
+
+			ratio = getVisibilityRatio(visibleHeight, totalBounds.height + totalBounds.y, totalBounds.height);
+			int bottom = getPixelLocation(ratio, zoomCanvasBounds.height, zoomCanvasBounds.height);
+
+			zoomRect.y  = top + BORDER_PADDING;
+			zoomRect.height = bottom - top - 2 * BORDER_PADDING - 1;
+
+		}
+
+		private double getVisibilityRatio(double visibleBound, double borderBound, double totalLength) {
+			double diff = visibleBound - borderBound;
+			return diff/totalLength;
+		}
+
+		private double getVisibilityRatio(IQuantity visibleBound, IQuantity borderBound, IQuantity totalLength) {
+			IQuantity diff = visibleBound.subtract(borderBound);
+			return diff.ratioTo(totalLength);
+		}
+
+		private int getPixelLocation(double visiblityRatio, int totalLength, int offset) {
+			return offset + (int) (visiblityRatio * totalLength);
+		}
+	}
+}