projects/dwt2: org.eclipse.jface/src/org/eclipse/jface/window/ToolTip.d comparison

comparison org.eclipse.jface/src/org/eclipse/jface/window/ToolTip.d @ 12:bc29606a740c

Added dwt-addons in original directory structure of eclipse.org

author	Frank Benoit <benoit@tionex.de>
date	Sat, 14 Mar 2009 18:23:29 +0100
parents
children	52184e4b815c

comparison

equal deleted inserted replaced

-:43904fec5dca
+:bc29606a740c
+/*******************************************************************************
+* Copyright (c) 2006, 2008 IBM Corporation and others.
+* 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:
+*     Tom Schindl <tom.schindl@bestsolution.at> - initial API and implementation
+*                                                 bugfix in: 195137, 198089, 225190
+* Port to the D programming language:
+*     Frank Benoit <benoit@tionex.de>
+*******************************************************************************/
+module org.eclipse.jface.window.ToolTip;
+import tango.util.log.Trace;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.DisposeEvent;
+import org.eclipse.swt.events.DisposeListener;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Monitor;
+import org.eclipse.swt.widgets.Shell;
+// import org.eclipse.jface.viewers.ColumnViewer;
+// import org.eclipse.jface.viewers.ViewerCell;
+import java.lang.all;
+import java.util.HashMap;
+import java.util.Set;
+import java.lang.JThread;
+/**
+* This class gives implementors to provide customized tooltips for any control.
+*
+* @since 3.3
+*/
+public abstract class ToolTip {
+private Control control;
+private int xShift = 3;
+private int yShift = 0;
+private int popupDelay = 0;
+private int hideDelay = 0;
+private ToolTipOwnerControlListener listener;
+private HashMap data;
+// Ensure that only one tooltip is active in time
+private static Shell CURRENT_TOOLTIP;
+/**
+* Recreate the tooltip on every mouse move
+*/
+public static const int RECREATE = 1;
+/**
+* Don't recreate the tooltip as long the mouse doesn't leave the area
+* triggering the tooltip creation
+*/
+public static const int NO_RECREATE = 1 << 1;
+private TooltipHideListener hideListener;
+private Listener shellListener;
+private bool hideOnMouseDown = true;
+private bool respectDisplayBounds = true;
+private bool respectMonitorBounds = true;
+private int style;
+private Object currentArea;
+private static final bool IS_OSX = SWT.getPlatform().equals("carbon"); //$NON-NLS-1$
+/**
+* Create new instance which add TooltipSupport to the widget
+*
+* @param control
+*            the control on whose action the tooltip is shown
+*/
+public this(Control control) {
+this(control, RECREATE, false);
+}
+/**
+* @param control
+*            the control to which the tooltip is bound
+* @param style
+*            style passed to control tooltip behavior
+*
+* @param manualActivation
+*            <code>true</code> if the activation is done manually using
+*            {@link #show(Point)}
+* @see #RECREATE
+* @see #NO_RECREATE
+*/
+public this(Control control, int style, bool manualActivation) {
+this.control = control;
+this.style = style;
+this.hideListener = new TooltipHideListener();
+this.control.addDisposeListener(new class DisposeListener {
+public void widgetDisposed(DisposeEvent e) {
+this.outer.data = null;
+this.outer.deactivate();
+}
+});
+this.listener = new ToolTipOwnerControlListener();
+this.shellListener = dgListener( (Event event_, Control control_, ToolTip tooltip_) {
+if( control_ !is null
+&& ! control_.isDisposed() ) {
+control_.getDisplay().asyncExec( dgRunnable( (Event event__, Control control__, ToolTip tooltip__){
+// Check if the new active shell is the tooltip
+// itself
+if( control__.getDisplay().getActiveShell() !is CURRENT_TOOLTIP) {
+tooltip__.toolTipHide(CURRENT_TOOLTIP, event__);
+}
+}, event_, control_, tooltip_));
+}
+}, control, this);
+if (!manualActivation) {
+activate();
+}
+}
+/**
+* Restore arbitrary data under the given key
+*
+* @param key
+*            the key
+* @param value
+*            the value
+*/
+public void setData(String key, Object value) {
+if (data is null) {
+data = new HashMap();
+}
+data.put(stringcast(key), value);
+}
+/**
+* Get the data restored under the key
+*
+* @param key
+*            the key
+* @return data or <code>null</code> if no entry is restored under the key
+*/
+public Object getData(String key) {
+if (data !is null) {
+return data.get(stringcast(key));
+}
+return null;
+}
+/**
+* Set the shift (from the mouse position triggered the event) used to
+* display the tooltip.
+* <p>
+* By default the tooltip is shifted 3 pixels to the right.
+* </p>
+*
+* @param p
+*            the new shift
+*/
+public void setShift(Point p) {
+xShift = p.x;
+yShift = p.y;
+}
+/**
+* Activate tooltip support for this control
+*/
+public void activate() {
+deactivate();
+control.addListener(SWT.Dispose, listener);
+control.addListener(SWT.MouseHover, listener);
+control.addListener(SWT.MouseMove, listener);
+control.addListener(SWT.MouseExit, listener);
+control.addListener(SWT.MouseDown, listener);
+control.addListener(SWT.MouseWheel, listener);
+}
+/**
+* Deactivate tooltip support for the underlying control
+*/
+public void deactivate() {
+control.removeListener(SWT.Dispose, listener);
+control.removeListener(SWT.MouseHover, listener);
+control.removeListener(SWT.MouseMove, listener);
+control.removeListener(SWT.MouseExit, listener);
+control.removeListener(SWT.MouseDown, listener);
+control.removeListener(SWT.MouseWheel, listener);
+}
+/**
+* Return whether the tooltip respects bounds of the display.
+*
+* @return <code>true</code> if the tooltip respects bounds of the display
+*/
+public bool isRespectDisplayBounds() {
+return respectDisplayBounds;
+}
+/**
+* Set to <code>false</code> if display bounds should not be respected or
+* to <code>true</code> if the tooltip is should repositioned to not
+* overlap the display bounds.
+* <p>
+* Default is <code>true</code>
+* </p>
+*
+* @param respectDisplayBounds
+*/
+public void setRespectDisplayBounds(bool respectDisplayBounds) {
+this.respectDisplayBounds = respectDisplayBounds;
+}
+/**
+* Return whether the tooltip respects bounds of the monitor.
+*
+* @return <code>true</code> if tooltip respects the bounds of the monitor
+*/
+public bool isRespectMonitorBounds() {
+return respectMonitorBounds;
+}
+/**
+* Set to <code>false</code> if monitor bounds should not be respected or
+* to <code>true</code> if the tooltip is should repositioned to not
+* overlap the monitors bounds. The monitor the tooltip belongs to is the
+* same is control's monitor the tooltip is shown for.
+* <p>
+* Default is <code>true</code>
+* </p>
+*
+* @param respectMonitorBounds
+*/
+public void setRespectMonitorBounds(bool respectMonitorBounds) {
+this.respectMonitorBounds = respectMonitorBounds;
+}
+/**
+* Should the tooltip displayed because of the given event.
+* <p>
+* <b>Subclasses may overwrite this to get custom behavior</b>
+* </p>
+*
+* @param event
+*            the event
+* @return <code>true</code> if tooltip should be displayed
+*/
+protected bool shouldCreateToolTip(Event event) {
+if ((style & NO_RECREATE) !is 0) {
+Object tmp = getToolTipArea(event);
+// No new area close the current tooltip
+if (tmp is null) {
+hide();
+return false;
+}
+bool rv = !tmp.opEquals(currentArea);
+return rv;
+}
+return true;
+}
+/**
+* This method is called before the tooltip is hidden
+*
+* @param event
+*            the event trying to hide the tooltip
+* @return <code>true</code> if the tooltip should be hidden
+*/
+private bool shouldHideToolTip(Event event) {
+if (event !is null && event.type is SWT.MouseMove
+&& (style & NO_RECREATE) !is 0) {
+Object tmp = getToolTipArea(event);
+// No new area close the current tooltip
+if (tmp is null) {
+hide();
+return false;
+}
+bool rv = !tmp.opEquals(currentArea);
+return rv;
+}
+return true;
+}
+/**
+* This method is called to check for which area the tooltip is
+* created/hidden for. In case of {@link #NO_RECREATE} this is used to
+* decide if the tooltip is hidden recreated.
+*
+* <code>By the default it is the widget the tooltip is created for but could be any object. To decide if
+* the area changed the {@link Object#equals(Object)} method is used.</code>
+*
+* @param event
+*            the event
+* @return the area responsible for the tooltip creation or
+*         <code>null</code> this could be any object describing the area
+*         (e.g. the {@link Control} onto which the tooltip is bound to, a
+*         part of this area e.g. for {@link ColumnViewer} this could be a
+*         {@link ViewerCell})
+*/
+protected Object getToolTipArea(Event event) {
+return control;
+}
+/**
+* Start up the tooltip programmatically
+*
+* @param location
+*            the location relative to the control the tooltip is shown
+*/
+public void show(Point location) {
+Event event = new Event();
+event.x = location.x;
+event.y = location.y;
+event.widget = control;
+toolTipCreate(event);
+}
+private Shell toolTipCreate(Event event) {
+if (shouldCreateToolTip(event)) {
+Shell shell = new Shell(control.getShell(), SWT.ON_TOP | SWT.TOOL
+| SWT.NO_FOCUS);
+shell.setLayout(new FillLayout());
+toolTipOpen(shell, event);
+return shell;
+}
+return null;
+}
+private void toolTipShow(Shell tip, Event event) {
+if (!tip.isDisposed()) {
+currentArea = getToolTipArea(event);
+createToolTipContentArea(event, tip);
+if (isHideOnMouseDown()) {
+toolTipHookBothRecursively(tip);
+} else {
+toolTipHookByTypeRecursively(tip, true, SWT.MouseExit);
+}
+tip.pack();
+Point size = tip.getSize();
+Point location = fixupDisplayBounds(size, getLocation(size, event));
+// Need to adjust a bit more if the mouse cursor.y is tip.y and
+// the cursor.x is inside the tip
+Point cursorLocation = tip.getDisplay().getCursorLocation();
+if (cursorLocation.y is location.y && location.x < cursorLocation.x
+&& location.x + size.x > cursorLocation.x) {
+location.y -= 2;
+}
+tip.setLocation(location);
+tip.setVisible(true);
+}
+}
+private Point fixupDisplayBounds(Point tipSize, Point location) {
+if (respectDisplayBounds || respectMonitorBounds) {
+Rectangle bounds;
+Point rightBounds = new Point(tipSize.x + location.x, tipSize.y
++ location.y);
+org.eclipse.swt.widgets.Monitor.Monitor[] ms = control.getDisplay().getMonitors();
+if (respectMonitorBounds && ms.length > 1) {
+// By default present in the monitor of the control
+bounds = control.getMonitor().getBounds();
+Point p = new Point(location.x, location.y);
+// Search on which monitor the event occurred
+Rectangle tmp;
+for (int i = 0; i < ms.length; i++) {
+tmp = ms[i].getBounds();
+if (tmp.contains(p)) {
+bounds = tmp;
+break;
+}
+}
+} else {
+bounds = control.getDisplay().getBounds();
+}
+if (!(bounds.contains(location) && bounds.contains(rightBounds))) {
+if (rightBounds.x > bounds.x + bounds.width) {
+location.x -= rightBounds.x - (bounds.x + bounds.width);
+}
+if (rightBounds.y > bounds.y + bounds.height) {
+location.y -= rightBounds.y - (bounds.y + bounds.height);
+}
+if (location.x < bounds.x) {
+location.x = bounds.x;
+}
+if (location.y < bounds.y) {
+location.y = bounds.y;
+}
+}
+}
+return location;
+}
+/**
+* Get the display relative location where the tooltip is displayed.
+* Subclasses may overwrite to implement custom positioning.
+*
+* @param tipSize
+*            the size of the tooltip to be shown
+* @param event
+*            the event triggered showing the tooltip
+* @return the absolute position on the display
+*/
+public Point getLocation(Point tipSize, Event event) {
+return control.toDisplay(event.x + xShift, event.y + yShift);
+}
+private void toolTipHide(Shell tip, Event event) {
+assert(this);
+if (tip !is null && !tip.isDisposed() && shouldHideToolTip(event)) {
+assert(this);
+control.getShell().removeListener(SWT.Deactivate, shellListener);
+currentArea = null;
+passOnEvent(tip, event);
+tip.dispose();
+CURRENT_TOOLTIP = null;
+afterHideToolTip(event);
+}
+}
+private void passOnEvent(Shell tip, Event event) {
+if (control !is null && !control.isDisposed() && event !is null
+&& event.widget !is control && event.type is SWT.MouseDown) {
+Display display = control.getDisplay();
+Point newPt = display.map(tip, null, new Point(event.x, event.y));
+Event newEvent = new Event();
+newEvent.button = event.button;
+newEvent.character = event.character;
+newEvent.count = event.count;
+newEvent.data = event.data;
+newEvent.detail = event.detail;
+newEvent.display = event.display;
+newEvent.doit = event.doit;
+newEvent.end = event.end;
+newEvent.gc = event.gc;
+newEvent.height = event.height;
+newEvent.index = event.index;
+newEvent.item = event.item;
+newEvent.keyCode = event.keyCode;
+newEvent.start = event.start;
+newEvent.stateMask = event.stateMask;
+newEvent.text = event.text;
+newEvent.time = event.time;
+newEvent.type = event.type;
+newEvent.widget = event.widget;
+newEvent.width = event.width;
+newEvent.x = newPt.x;
+newEvent.y = newPt.y;
+tip.close();
+display.asyncExec(dgRunnable( delegate(Display display_, Event newEvent_) {
+if (IS_OSX) {
+try {
+JThread.sleep(300);
+} catch (InterruptedException e) {
+}
+display_.post(newEvent_);
+newEvent_.type = SWT.MouseUp;
+display_.post(newEvent_);
+} else {
+display_.post(newEvent_);
+}
+}, display,newEvent));
+}
+}
+private void toolTipOpen(Shell shell, Event event) {
+// Ensure that only one Tooltip is shown in time
+if (CURRENT_TOOLTIP !is null) {
+toolTipHide(CURRENT_TOOLTIP, null);
+}
+CURRENT_TOOLTIP = shell;
+control.getShell().addListener(SWT.Deactivate, shellListener);
+if (popupDelay > 0) {
+control.getDisplay().timerExec(popupDelay, dgRunnable( (Shell shell_,Event event_, ToolTip tooltip_){
+assert(tooltip_);
+tooltip_.toolTipShow(shell_, event_);
+},shell,event, this));
+} else {
+toolTipShow(CURRENT_TOOLTIP, event);
+}
+if (hideDelay > 0) {
+control.getDisplay().timerExec(popupDelay + hideDelay, dgRunnable( (Shell shell_, ToolTip tooltip_){
+assert(tooltip_);
+tooltip_.toolTipHide(shell_, null);
+}, shell, this ));
+}
+}
+private void toolTipHookByTypeRecursively(Control c, bool add, int type) {
+if (add) {
+c.addListener(type, hideListener);
+} else {
+c.removeListener(type, hideListener);
+}
+if ( auto c2 = cast(Composite)c ) {
+Control[] children = c2.getChildren();
+for (int i = 0; i < children.length; i++) {
+toolTipHookByTypeRecursively(children[i], add, type);
+}
+}
+}
+private void toolTipHookBothRecursively(Control c) {
+c.addListener(SWT.MouseDown, hideListener);
+c.addListener(SWT.MouseExit, hideListener);
+if ( auto comp = cast(Composite) c ) {
+Control[] children = comp.getChildren();
+for (int i = 0; i < children.length; i++) {
+toolTipHookBothRecursively(children[i]);
+}
+}
+}
+/**
+* Creates the content area of the the tooltip.
+*
+* @param event
+*            the event that triggered the activation of the tooltip
+* @param parent
+*            the parent of the content area
+* @return the content area created
+*/
+protected abstract Composite createToolTipContentArea(Event event,
+Composite parent);
+/**
+* This method is called after a tooltip is hidden.
+* <p>
+* <b>Subclasses may override to clean up requested system resources</b>
+* </p>
+*
+* @param event
+*            event triggered the hiding action (may be <code>null</code>
+*            if event wasn't triggered by user actions directly)
+*/
+protected void afterHideToolTip(Event event) {
+}
+/**
+* Set the hide delay.
+*
+* @param hideDelay
+*            the delay before the tooltip is hidden. If <code>0</code>
+*            the tooltip is shown until user moves to other item
+*/
+public void setHideDelay(int hideDelay) {
+this.hideDelay = hideDelay;
+}
+/**
+* Set the popup delay.
+*
+* @param popupDelay
+*            the delay before the tooltip is shown to the user. If
+*            <code>0</code> the tooltip is shown immediately
+*/
+public void setPopupDelay(int popupDelay) {
+this.popupDelay = popupDelay;
+}
+/**
+* Return if hiding on mouse down is set.
+*
+* @return <code>true</code> if hiding on mouse down in the tool tip is on
+*/
+public bool isHideOnMouseDown() {
+return hideOnMouseDown;
+}
+/**
+* If you don't want the tool tip to be hidden when the user clicks inside
+* the tool tip set this to <code>false</code>. You maybe also need to
+* hide the tool tip yourself depending on what you do after clicking in the
+* tooltip (e.g. if you open a new {@link Shell})
+*
+* @param hideOnMouseDown
+*            flag to indicate of tooltip is hidden automatically on mouse
+*            down inside the tool tip
+*/
+public void setHideOnMouseDown(bool hideOnMouseDown) {
+// Only needed if there's currently a tooltip active
+if (CURRENT_TOOLTIP !is null && !CURRENT_TOOLTIP.isDisposed()) {
+// Only change if value really changed
+if (hideOnMouseDown !is this.hideOnMouseDown) {
+control.getDisplay().syncExec(new class(hideOnMouseDown) Runnable {
+bool hideOnMouseDown_;
+this(bool a){ hideOnMouseDown_=a; }
+public void run() {
+if (CURRENT_TOOLTIP !is null
+&& CURRENT_TOOLTIP.isDisposed()) {
+toolTipHookByTypeRecursively(CURRENT_TOOLTIP,
+hideOnMouseDown_, SWT.MouseDown);
+}
+}
+});
+}
+}
+this.hideOnMouseDown = hideOnMouseDown;
+}
+/**
+* Hide the currently active tool tip
+*/
+public void hide() {
+toolTipHide(CURRENT_TOOLTIP, null);
+}
+private class ToolTipOwnerControlListener : Listener {
+public void handleEvent(Event event) {
+switch (event.type) {
+case SWT.Dispose:
+case SWT.KeyDown:
+case SWT.MouseDown:
+case SWT.MouseMove:
+case SWT.MouseWheel:
+toolTipHide(CURRENT_TOOLTIP, event);
+break;
+case SWT.MouseHover:
+toolTipCreate(event);
+break;
+case SWT.MouseExit:
+/*
+* Check if the mouse exit happened because we move over the
+* tooltip
+*/
+if (CURRENT_TOOLTIP !is null && !CURRENT_TOOLTIP.isDisposed()) {
+if (CURRENT_TOOLTIP.getBounds().contains(
+control.toDisplay(event.x, event.y))) {
+break;
+}
+}
+toolTipHide(CURRENT_TOOLTIP, event);
+break;
+default:
+}
+}
+}
+private class TooltipHideListener : Listener {
+public void handleEvent(Event event) {
+if ( auto c = cast(Control)event.widget ) {
+Shell shell = c.getShell();
+switch (event.type) {
+case SWT.MouseDown:
+if (isHideOnMouseDown()) {
+toolTipHide(shell, event);
+}
+break;
+case SWT.MouseExit:
+/*
+* Give some insets to ensure we get exit informations from
+* a wider area ;-)
+*/
+Rectangle rect = shell.getBounds();
+rect.x += 5;
+rect.y += 5;
+rect.width -= 10;
+rect.height -= 10;
+if (!rect.contains(c.getDisplay().getCursorLocation())) {
+toolTipHide(shell, event);
+}
+break;
+default:
+}
+}
+}
+}
+}

Mercurial > projects > dwt2

comparison org.eclipse.jface/src/org/eclipse/jface/window/ToolTip.d @ 12:bc29606a740c