X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.eclipse.swt.win32.win32.x86_64%2Fsrc%2Forg%2Feclipse%2Fswt%2Fwidgets%2FTracker.java;fp=bundles%2Forg.eclipse.swt.win32.win32.x86_64%2Fsrc%2Forg%2Feclipse%2Fswt%2Fwidgets%2FTracker.java;h=ba256fea18b1b86a685c9620305bb7e717191d4e;hb=6b98970d0458754dd67f789afbd0a39e1e7ac6eb;hp=0000000000000000000000000000000000000000;hpb=56a61575ce0d27b340cb12438c8a7f303842095e;p=simantics%2Fplatform.git diff --git a/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/widgets/Tracker.java b/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/widgets/Tracker.java new file mode 100644 index 000000000..ba256fea1 --- /dev/null +++ b/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/widgets/Tracker.java @@ -0,0 +1,1246 @@ +/******************************************************************************* + * Copyright (c) 2000, 2013 IBM Corporation and others. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.widgets; + + +import org.eclipse.swt.*; +import org.eclipse.swt.events.*; +import org.eclipse.swt.graphics.*; +import org.eclipse.swt.internal.*; +import org.eclipse.swt.internal.win32.*; + +/** + * Instances of this class implement rubber banding rectangles that are + * drawn onto a parent Composite or Display. + * These rectangles can be specified to respond to mouse and key events + * by either moving or resizing themselves accordingly. Trackers are + * typically used to represent window geometries in a lightweight manner. + * + *
+ *
Styles:
+ *
LEFT, RIGHT, UP, DOWN, RESIZE
+ *
Events:
+ *
Move, Resize
+ *
+ *

+ * Note: Rectangle move behavior is assumed unless RESIZE is specified. + *

+ * IMPORTANT: This class is not intended to be subclassed. + *

+ * + * @see Tracker snippets + * @see Sample code and further information + * @noextend This class is not intended to be subclassed by clients. + */ +public class Tracker extends Widget { + Control parent; + boolean tracking, cancelled, stippled; + Rectangle [] rectangles = new Rectangle [0], proportions = rectangles; + Rectangle bounds; + long resizeCursor; + Cursor clientCursor; + int cursorOrientation = SWT.NONE; + boolean inEvent = false; + boolean drawn; + long hwndTransparent, hwndOpaque, oldTransparentProc, oldOpaqueProc; + int oldX, oldY; + + /* + * The following values mirror step sizes on Windows + */ + final static int STEPSIZE_SMALL = 1; + final static int STEPSIZE_LARGE = 9; + +/** + * Constructs a new instance of this class given its parent + * and a style value describing its behavior and appearance. + *

+ * The style value is either one of the style constants defined in + * class SWT which is applicable to instances of this + * class, or must be built by bitwise OR'ing together + * (that is, using the int "|" operator) two or more + * of those SWT style constants. The class description + * lists the style constants that are applicable to the class. + * Style bits are also inherited from superclasses. + *

+ * + * @param parent a widget which will be the parent of the new instance (cannot be null) + * @param style the style of widget to construct + * + * @exception IllegalArgumentException + * @exception SWTException + * + * @see SWT#LEFT + * @see SWT#RIGHT + * @see SWT#UP + * @see SWT#DOWN + * @see SWT#RESIZE + * @see Widget#checkSubclass + * @see Widget#getStyle + */ +public Tracker (Composite parent, int style) { + super (parent, checkStyle (style)); + this.parent = parent; +} + +/** + * Constructs a new instance of this class given the display + * to create it on and a style value describing its behavior + * and appearance. + *

+ * The style value is either one of the style constants defined in + * class SWT which is applicable to instances of this + * class, or must be built by bitwise OR'ing together + * (that is, using the int "|" operator) two or more + * of those SWT style constants. The class description + * lists the style constants that are applicable to the class. + * Style bits are also inherited from superclasses. + *

+ * Note: Currently, null can be passed in for the display argument. + * This has the effect of creating the tracker on the currently active + * display if there is one. If there is no current display, the + * tracker is created on a "default" display. Passing in null as + * the display argument is not considered to be good coding style, + * and may not be supported in a future release of SWT. + *

+ * + * @param display the display to create the tracker on + * @param style the style of control to construct + * + * @exception SWTException + * + * @see SWT#LEFT + * @see SWT#RIGHT + * @see SWT#UP + * @see SWT#DOWN + * @see SWT#RESIZE + */ +public Tracker (Display display, int style) { + if (display == null) display = Display.getCurrent (); + if (display == null) display = Display.getDefault (); + if (!display.isValidThread ()) { + error (SWT.ERROR_THREAD_INVALID_ACCESS); + } + this.style = checkStyle (style); + this.display = display; + reskinWidget (); +} + +/** + * Adds the listener to the collection of listeners who will + * be notified when the control is moved or resized, by sending + * it one of the messages defined in the ControlListener + * interface. + * + * @param listener the listener which should be notified + * + * @exception IllegalArgumentException + * @exception SWTException + * + * @see ControlListener + * @see #removeControlListener + */ +public void addControlListener (ControlListener listener) { + checkWidget (); + if (listener == null) error (SWT.ERROR_NULL_ARGUMENT); + TypedListener typedListener = new TypedListener (listener); + addListener (SWT.Resize, typedListener); + addListener (SWT.Move, typedListener); +} + +/** + * Adds the listener to the collection of listeners who will + * be notified when keys are pressed and released on the system keyboard, by sending + * it one of the messages defined in the KeyListener + * interface. + * + * @param listener the listener which should be notified + * + * @exception IllegalArgumentException + * @exception SWTException + * + * @see KeyListener + * @see #removeKeyListener + */ +public void addKeyListener (KeyListener listener) { + checkWidget (); + if (listener == null) error (SWT.ERROR_NULL_ARGUMENT); + TypedListener typedListener = new TypedListener (listener); + addListener (SWT.KeyUp,typedListener); + addListener (SWT.KeyDown,typedListener); +} + +Point adjustMoveCursor () { + if (bounds == null) return null; + int newX = bounds.x + bounds.width / 2; + int newY = bounds.y; + POINT pt = new POINT (); + pt.x = newX; pt.y = newY; + /* + * Convert to screen coordinates iff needed + */ + if (parent != null) { + OS.ClientToScreen (parent.handle, pt); + } + OS.SetCursorPos (pt.x, pt.y); + return new Point (pt.x, pt.y); +} + +Point adjustResizeCursor () { + if (bounds == null) return null; + int newX, newY; + + if ((cursorOrientation & SWT.LEFT) != 0) { + newX = bounds.x; + } else if ((cursorOrientation & SWT.RIGHT) != 0) { + newX = bounds.x + bounds.width; + } else { + newX = bounds.x + bounds.width / 2; + } + + if ((cursorOrientation & SWT.UP) != 0) { + newY = bounds.y; + } else if ((cursorOrientation & SWT.DOWN) != 0) { + newY = bounds.y + bounds.height; + } else { + newY = bounds.y + bounds.height / 2; + } + + POINT pt = new POINT (); + pt.x = newX; pt.y = newY; + /* + * Convert to screen coordinates iff needed + */ + if (parent != null) { + OS.ClientToScreen (parent.handle, pt); + } + OS.SetCursorPos (pt.x, pt.y); + + /* + * If the client has not provided a custom cursor then determine + * the appropriate resize cursor. + */ + if (clientCursor == null) { + long newCursor = 0; + switch (cursorOrientation) { + case SWT.UP: + newCursor = OS.LoadCursor (0, OS.IDC_SIZENS); + break; + case SWT.DOWN: + newCursor = OS.LoadCursor (0, OS.IDC_SIZENS); + break; + case SWT.LEFT: + newCursor = OS.LoadCursor (0, OS.IDC_SIZEWE); + break; + case SWT.RIGHT: + newCursor = OS.LoadCursor (0, OS.IDC_SIZEWE); + break; + case SWT.LEFT | SWT.UP: + newCursor = OS.LoadCursor (0, OS.IDC_SIZENWSE); + break; + case SWT.RIGHT | SWT.DOWN: + newCursor = OS.LoadCursor (0, OS.IDC_SIZENWSE); + break; + case SWT.LEFT | SWT.DOWN: + newCursor = OS.LoadCursor (0, OS.IDC_SIZENESW); + break; + case SWT.RIGHT | SWT.UP: + newCursor = OS.LoadCursor (0, OS.IDC_SIZENESW); + break; + default: + newCursor = OS.LoadCursor (0, OS.IDC_SIZEALL); + break; + } + OS.SetCursor (newCursor); + if (resizeCursor != 0) { + OS.DestroyCursor (resizeCursor); + } + resizeCursor = newCursor; + } + + return new Point (pt.x, pt.y); +} + +static int checkStyle (int style) { + if ((style & (SWT.LEFT | SWT.RIGHT | SWT.UP | SWT.DOWN)) == 0) { + style |= SWT.LEFT | SWT.RIGHT | SWT.UP | SWT.DOWN; + } + return style; +} + +/** + * Stops displaying the tracker rectangles. Note that this is not considered + * to be a cancelation by the user. + * + * @exception SWTException + */ +public void close () { + checkWidget (); + tracking = false; +} + +Rectangle computeBounds () { + if (rectangles.length == 0) return null; + int xMin = rectangles [0].x; + int yMin = rectangles [0].y; + int xMax = rectangles [0].x + rectangles [0].width; + int yMax = rectangles [0].y + rectangles [0].height; + + for (int i = 1; i < rectangles.length; i++) { + if (rectangles [i].x < xMin) xMin = rectangles [i].x; + if (rectangles [i].y < yMin) yMin = rectangles [i].y; + int rectRight = rectangles [i].x + rectangles [i].width; + if (rectRight > xMax) xMax = rectRight; + int rectBottom = rectangles [i].y + rectangles [i].height; + if (rectBottom > yMax) yMax = rectBottom; + } + + return new Rectangle (xMin, yMin, xMax - xMin, yMax - yMin); +} + +Rectangle [] computeProportions (Rectangle [] rects) { + Rectangle [] result = new Rectangle [rects.length]; + bounds = computeBounds (); + if (bounds != null) { + for (int i = 0; i < rects.length; i++) { + int x = 0, y = 0, width = 0, height = 0; + if (bounds.width != 0) { + x = (rects [i].x - bounds.x) * 100 / bounds.width; + width = rects [i].width * 100 / bounds.width; + } else { + width = 100; + } + if (bounds.height != 0) { + y = (rects [i].y - bounds.y) * 100 / bounds.height; + height = rects [i].height * 100 / bounds.height; + } else { + height = 100; + } + result [i] = new Rectangle (x, y, width, height); + } + } + return result; +} + +/** + * Draw the rectangles displayed by the tracker. + */ +void drawRectangles (Rectangle [] rects, boolean stippled) { + if (hwndOpaque != 0) { + RECT rect1 = new RECT(); + int bandWidth = stippled ? 3 : 1; + for (int i = 0; i < rects.length; i++) { + Rectangle rect = rects[i]; + rect1.left = rect.x - bandWidth; + rect1.top = rect.y - bandWidth; + rect1.right = rect.x + rect.width + bandWidth * 2; + rect1.bottom = rect.y + rect.height + bandWidth * 2; + OS.MapWindowPoints (0, hwndOpaque, rect1, 2); + OS.RedrawWindow (hwndOpaque, rect1, 0, OS.RDW_INVALIDATE); + } + return; + } + int bandWidth = 1; + long hwndTrack = parent == null ? OS.GetDesktopWindow () : parent.handle; + long hDC = OS.GetDCEx (hwndTrack, 0, OS.DCX_CACHE); + long hBitmap = 0, hBrush = 0, oldBrush = 0; + if (stippled) { + bandWidth = 3; + byte [] bits = {-86, 0, 85, 0, -86, 0, 85, 0, -86, 0, 85, 0, -86, 0, 85, 0}; + hBitmap = OS.CreateBitmap (8, 8, 1, 1, bits); + hBrush = OS.CreatePatternBrush (hBitmap); + oldBrush = OS.SelectObject (hDC, hBrush); + } + for (int i=0; iDisplay then these are screen + * coordinates. + * + * @return the bounds of the Rectangles being drawn + * + * @exception SWTException + */ +public Rectangle [] getRectangles () { + checkWidget(); + Rectangle [] result = getRectanglesInPixels(); + for (int i = 0; i < result.length; i++) { + result[i] = DPIUtil.autoScaleDown(result[i]); + } + return result; +} + +Rectangle [] getRectanglesInPixels () { + Rectangle [] result = new Rectangle [rectangles.length]; + for (int i = 0; i < rectangles.length; i++) { + Rectangle current = rectangles [i]; + result [i] = new Rectangle (current.x, current.y, current.width, current.height); + } + return result; +} + +/** + * Returns true if the rectangles are drawn with a stippled line, false otherwise. + * + * @return the stippled effect of the rectangles + * + * @exception SWTException + */ +public boolean getStippled () { + checkWidget (); + return stippled; +} + +void moveRectangles (int xChange, int yChange) { + if (bounds == null) return; + if (xChange < 0 && ((style & SWT.LEFT) == 0)) xChange = 0; + if (xChange > 0 && ((style & SWT.RIGHT) == 0)) xChange = 0; + if (yChange < 0 && ((style & SWT.UP) == 0)) yChange = 0; + if (yChange > 0 && ((style & SWT.DOWN) == 0)) yChange = 0; + if (xChange == 0 && yChange == 0) return; + bounds.x += xChange; bounds.y += yChange; + for (int i = 0; i < rectangles.length; i++) { + rectangles [i].x += xChange; + rectangles [i].y += yChange; + } +} + +/** + * Displays the Tracker rectangles for manipulation by the user. Returns when + * the user has either finished manipulating the rectangles or has cancelled the + * Tracker. + * + * @return true if the user did not cancel the Tracker, false otherwise + * + * @exception SWTException + */ +public boolean open () { + checkWidget (); + cancelled = false; + tracking = true; + + /* + * If exactly one of UP/DOWN is specified as a style then set the cursor + * orientation accordingly (the same is done for LEFT/RIGHT styles below). + */ + int vStyle = style & (SWT.UP | SWT.DOWN); + if (vStyle == SWT.UP || vStyle == SWT.DOWN) { + cursorOrientation |= vStyle; + } + int hStyle = style & (SWT.LEFT | SWT.RIGHT); + if (hStyle == SWT.LEFT || hStyle == SWT.RIGHT) { + cursorOrientation |= hStyle; + } + + Callback newProc = null; + boolean mouseDown = OS.GetKeyState(OS.VK_LBUTTON) < 0; + /* + * Bug in Vista. Drawing directly to the screen with XOR does not + * perform well. The fix is to draw on layered window instead. + * + * Note that one window (almost opaque) is used for catching all events and a + * second window is used for drawing the rectangles. + */ + if (parent == null) { + Rectangle bounds = display.getBoundsInPixels(); + hwndTransparent = OS.CreateWindowEx ( + OS.WS_EX_LAYERED | OS.WS_EX_NOACTIVATE | OS.WS_EX_TOOLWINDOW, + display.windowClass, + null, + OS.WS_POPUP, + bounds.x, bounds.y, + bounds.width, bounds.height, + 0, + 0, + OS.GetModuleHandle (null), + null); + OS.SetLayeredWindowAttributes (hwndTransparent, 0, (byte)0x01, OS.LWA_ALPHA); + hwndOpaque = OS.CreateWindowEx ( + OS.WS_EX_LAYERED | OS.WS_EX_NOACTIVATE | OS.WS_EX_TOOLWINDOW, + display.windowClass, + null, + OS.WS_POPUP, + bounds.x, bounds.y, + bounds.width, bounds.height, + hwndTransparent, + 0, + OS.GetModuleHandle (null), + null); + OS.SetLayeredWindowAttributes (hwndOpaque, 0xFFFFFF, (byte)0, OS.LWA_COLORKEY | OS.LWA_ALPHA); + drawn = false; + newProc = new Callback (this, "transparentProc", 4); //$NON-NLS-1$ + long newProcAddress = newProc.getAddress (); + if (newProcAddress == 0) error (SWT.ERROR_NO_MORE_CALLBACKS); + oldTransparentProc = OS.GetWindowLongPtr (hwndTransparent, OS.GWLP_WNDPROC); + OS.SetWindowLongPtr (hwndTransparent, OS.GWLP_WNDPROC, newProcAddress); + oldOpaqueProc = OS.GetWindowLongPtr (hwndOpaque, OS.GWLP_WNDPROC); + OS.SetWindowLongPtr (hwndOpaque, OS.GWLP_WNDPROC, newProcAddress); + OS.ShowWindow (hwndTransparent, OS.SW_SHOWNOACTIVATE); + OS.ShowWindow (hwndOpaque, OS.SW_SHOWNOACTIVATE); + } else { + /* + * If this tracker is being created without a mouse drag then + * we need to create a transparent window that fills the screen + * in order to get all mouse/keyboard events that occur + * outside of our visible windows (ie.- over the desktop). + */ + if (!mouseDown) { + Rectangle bounds = display.getBoundsInPixels(); + hwndTransparent = OS.CreateWindowEx ( + OS.WS_EX_TRANSPARENT, + display.windowClass, + null, + OS.WS_POPUP, + bounds.x, bounds.y, + bounds.width, bounds.height, + 0, + 0, + OS.GetModuleHandle (null), + null); + newProc = new Callback (this, "transparentProc", 4); //$NON-NLS-1$ + long newProcAddress = newProc.getAddress (); + if (newProcAddress == 0) error (SWT.ERROR_NO_MORE_CALLBACKS); + oldTransparentProc = OS.GetWindowLongPtr (hwndTransparent, OS.GWLP_WNDPROC); + OS.SetWindowLongPtr (hwndTransparent, OS.GWLP_WNDPROC, newProcAddress); + OS.ShowWindow (hwndTransparent, OS.SW_SHOWNOACTIVATE); + } + } + + update (); + drawRectangles (rectangles, stippled); + Point cursorPos = null; + if (mouseDown) { + POINT pt = new POINT (); + OS.GetCursorPos (pt); + cursorPos = new Point (pt.x, pt.y); + } else { + if ((style & SWT.RESIZE) != 0) { + cursorPos = adjustResizeCursor (); + } else { + cursorPos = adjustMoveCursor (); + } + } + if (cursorPos != null) { + oldX = cursorPos.x; + oldY = cursorPos.y; + } + + Display display = this.display; + try { + /* Tracker behaves like a Dialog with its own OS event loop. */ + MSG msg = new MSG (); + while (tracking && !cancelled) { + if (parent != null && parent.isDisposed ()) break; + display.runSkin (); + display.runDeferredLayouts (); + display.sendPreExternalEventDispatchEvent (); + OS.GetMessage (msg, 0, 0, 0); + display.sendPostExternalEventDispatchEvent (); + OS.TranslateMessage (msg); + switch (msg.message) { + case OS.WM_LBUTTONUP: + case OS.WM_MOUSEMOVE: + wmMouse (msg.message, msg.wParam, msg.lParam); + break; + case OS.WM_IME_CHAR: wmIMEChar (msg.hwnd, msg.wParam, msg.lParam); break; + case OS.WM_CHAR: wmChar (msg.hwnd, msg.wParam, msg.lParam); break; + case OS.WM_KEYDOWN: wmKeyDown (msg.hwnd, msg.wParam, msg.lParam); break; + case OS.WM_KEYUP: wmKeyUp (msg.hwnd, msg.wParam, msg.lParam); break; + case OS.WM_SYSCHAR: wmSysChar (msg.hwnd, msg.wParam, msg.lParam); break; + case OS.WM_SYSKEYDOWN: wmSysKeyDown (msg.hwnd, msg.wParam, msg.lParam); break; + case OS.WM_SYSKEYUP: wmSysKeyUp (msg.hwnd, msg.wParam, msg.lParam); break; + } + if (OS.WM_KEYFIRST <= msg.message && msg.message <= OS.WM_KEYLAST) continue; + if (OS.WM_MOUSEFIRST <= msg.message && msg.message <= OS.WM_MOUSELAST) continue; + if (hwndOpaque == 0) { + if (msg.message == OS.WM_PAINT) { + update (); + drawRectangles (rectangles, stippled); + } + } + OS.DispatchMessage (msg); + if (hwndOpaque == 0) { + if (msg.message == OS.WM_PAINT) { + drawRectangles (rectangles, stippled); + } + } + display.runAsyncMessages (false); + } + if (mouseDown) OS.ReleaseCapture (); + if (!isDisposed()) { + update (); + drawRectangles (rectangles, stippled); + } + } finally { + /* + * Cleanup: If a transparent window was created in order to capture events then + * destroy it and its callback object now. + */ + if (hwndTransparent != 0) { + OS.DestroyWindow (hwndTransparent); + hwndTransparent = 0; + } + hwndOpaque = 0; + if (newProc != null) { + newProc.dispose (); + oldTransparentProc = oldOpaqueProc = 0; + } + /* + * Cleanup: If this tracker was resizing then the last cursor that it created + * needs to be destroyed. + */ + if (resizeCursor != 0) { + OS.DestroyCursor (resizeCursor); + resizeCursor = 0; + } + } + tracking = false; + return !cancelled; +} + +@Override +void releaseWidget () { + super.releaseWidget (); + parent = null; + rectangles = proportions = null; + bounds = null; +} + +/** + * Removes the listener from the collection of listeners who will + * be notified when the control is moved or resized. + * + * @param listener the listener which should no longer be notified + * + * @exception IllegalArgumentException + * @exception SWTException + * + * @see ControlListener + * @see #addControlListener + */ +public void removeControlListener (ControlListener listener) { + checkWidget (); + if (listener == null) error (SWT.ERROR_NULL_ARGUMENT); + if (eventTable == null) return; + eventTable.unhook (SWT.Resize, listener); + eventTable.unhook (SWT.Move, listener); +} + +/** + * Removes the listener from the collection of listeners who will + * be notified when keys are pressed and released on the system keyboard. + * + * @param listener the listener which should no longer be notified + * + * @exception IllegalArgumentException + * @exception SWTException + * + * @see KeyListener + * @see #addKeyListener + */ +public void removeKeyListener(KeyListener listener) { + checkWidget (); + if (listener == null) error (SWT.ERROR_NULL_ARGUMENT); + if (eventTable == null) return; + eventTable.unhook (SWT.KeyUp, listener); + eventTable.unhook (SWT.KeyDown, listener); +} + +void resizeRectangles (int xChange, int yChange) { + if (bounds == null) return; + /* + * If the cursor orientation has not been set in the orientation of + * this change then try to set it here. + */ + if (xChange < 0 && ((style & SWT.LEFT) != 0) && ((cursorOrientation & SWT.RIGHT) == 0)) { + cursorOrientation |= SWT.LEFT; + } + if (xChange > 0 && ((style & SWT.RIGHT) != 0) && ((cursorOrientation & SWT.LEFT) == 0)) { + cursorOrientation |= SWT.RIGHT; + } + if (yChange < 0 && ((style & SWT.UP) != 0) && ((cursorOrientation & SWT.DOWN) == 0)) { + cursorOrientation |= SWT.UP; + } + if (yChange > 0 && ((style & SWT.DOWN) != 0) && ((cursorOrientation & SWT.UP) == 0)) { + cursorOrientation |= SWT.DOWN; + } + + /* + * If the bounds will flip about the x or y axis then apply the adjustment + * up to the axis (ie.- where bounds width/height becomes 0), change the + * cursor's orientation accordingly, and flip each Rectangle's origin (only + * necessary for > 1 Rectangles) + */ + if ((cursorOrientation & SWT.LEFT) != 0) { + if (xChange > bounds.width) { + if ((style & SWT.RIGHT) == 0) return; + cursorOrientation |= SWT.RIGHT; + cursorOrientation &= ~SWT.LEFT; + bounds.x += bounds.width; + xChange -= bounds.width; + bounds.width = 0; + if (proportions.length > 1) { + for (int i = 0; i < proportions.length; i++) { + Rectangle proportion = proportions [i]; + proportion.x = 100 - proportion.x - proportion.width; + } + } + } + } else if ((cursorOrientation & SWT.RIGHT) != 0) { + if (bounds.width < -xChange) { + if ((style & SWT.LEFT) == 0) return; + cursorOrientation |= SWT.LEFT; + cursorOrientation &= ~SWT.RIGHT; + xChange += bounds.width; + bounds.width = 0; + if (proportions.length > 1) { + for (int i = 0; i < proportions.length; i++) { + Rectangle proportion = proportions [i]; + proportion.x = 100 - proportion.x - proportion.width; + } + } + } + } + if ((cursorOrientation & SWT.UP) != 0) { + if (yChange > bounds.height) { + if ((style & SWT.DOWN) == 0) return; + cursorOrientation |= SWT.DOWN; + cursorOrientation &= ~SWT.UP; + bounds.y += bounds.height; + yChange -= bounds.height; + bounds.height = 0; + if (proportions.length > 1) { + for (int i = 0; i < proportions.length; i++) { + Rectangle proportion = proportions [i]; + proportion.y = 100 - proportion.y - proportion.height; + } + } + } + } else if ((cursorOrientation & SWT.DOWN) != 0) { + if (bounds.height < -yChange) { + if ((style & SWT.UP) == 0) return; + cursorOrientation |= SWT.UP; + cursorOrientation &= ~SWT.DOWN; + yChange += bounds.height; + bounds.height = 0; + if (proportions.length > 1) { + for (int i = 0; i < proportions.length; i++) { + Rectangle proportion = proportions [i]; + proportion.y = 100 - proportion.y - proportion.height; + } + } + } + } + + // apply the bounds adjustment + if ((cursorOrientation & SWT.LEFT) != 0) { + bounds.x += xChange; + bounds.width -= xChange; + } else if ((cursorOrientation & SWT.RIGHT) != 0) { + bounds.width += xChange; + } + if ((cursorOrientation & SWT.UP) != 0) { + bounds.y += yChange; + bounds.height -= yChange; + } else if ((cursorOrientation & SWT.DOWN) != 0) { + bounds.height += yChange; + } + + Rectangle [] newRects = new Rectangle [rectangles.length]; + for (int i = 0; i < rectangles.length; i++) { + Rectangle proportion = proportions[i]; + newRects[i] = new Rectangle ( + proportion.x * bounds.width / 100 + bounds.x, + proportion.y * bounds.height / 100 + bounds.y, + proportion.width * bounds.width / 100, + proportion.height * bounds.height / 100); + } + rectangles = newRects; +} + +/** + * Sets the Cursor of the Tracker. If this cursor is null + * then the cursor reverts to the default. + * + * @param newCursor the new Cursor to display + * + * @exception SWTException + */ +public void setCursor(Cursor newCursor) { + checkWidget(); + clientCursor = newCursor; + if (newCursor != null) { + if (inEvent) OS.SetCursor (clientCursor.handle); + } +} + +/** + * Specifies the rectangles that should be drawn, expressed relative to the parent + * widget. If the parent is a Display then these are screen coordinates. + * + * @param rectangles the bounds of the rectangles to be drawn + * + * @exception IllegalArgumentException + * @exception SWTException + */ +public void setRectangles (Rectangle [] rectangles) { + checkWidget (); + if (rectangles == null) error (SWT.ERROR_NULL_ARGUMENT); + Rectangle [] rectanglesInPixels = new Rectangle [rectangles.length]; + for (int i = 0; i < rectangles.length; i++) { + rectanglesInPixels [i] = DPIUtil.autoScaleUp (rectangles [i]); + } + setRectanglesInPixels (rectanglesInPixels); +} + +void setRectanglesInPixels (Rectangle [] rectangles) { + this.rectangles = new Rectangle [rectangles.length]; + for (int i = 0; i < rectangles.length; i++) { + Rectangle current = rectangles [i]; + if (current == null) error (SWT.ERROR_NULL_ARGUMENT); + this.rectangles [i] = new Rectangle (current.x, current.y, current.width, current.height); + } + proportions = computeProportions (rectangles); +} + +/** + * Changes the appearance of the line used to draw the rectangles. + * + * @param stippled true if rectangle should appear stippled + * + * @exception SWTException + */ +public void setStippled (boolean stippled) { + checkWidget (); + this.stippled = stippled; +} + +long transparentProc (long hwnd, long msg, long wParam, long lParam) { + switch ((int)msg) { + /* + * We typically do not want to answer that the transparent window is + * transparent to hits since doing so negates the effect of having it + * to grab events. However, clients of the tracker should not be aware + * of this transparent window. Therefore if there is a hit query + * performed as a result of client code then answer that the transparent + * window is transparent to hits so that its existence will not impact + * the client. + */ + case OS.WM_NCHITTEST: + if (inEvent) return OS.HTTRANSPARENT; + break; + case OS.WM_SETCURSOR: + if (clientCursor != null) { + OS.SetCursor (clientCursor.handle); + return 1; + } + if (resizeCursor != 0) { + OS.SetCursor (resizeCursor); + return 1; + } + break; + case OS.WM_PAINT: + if (hwndOpaque == hwnd) { + PAINTSTRUCT ps = new PAINTSTRUCT(); + long hDC = OS.BeginPaint (hwnd, ps); + long hBitmap = 0, hBrush = 0, oldBrush = 0; + long transparentBrush = OS.CreateSolidBrush(0xFFFFFF); + oldBrush = OS.SelectObject (hDC, transparentBrush); + OS.PatBlt (hDC, ps.left, ps.top, ps.right - ps.left, ps.bottom - ps.top, OS.PATCOPY); + OS.SelectObject (hDC, oldBrush); + OS.DeleteObject (transparentBrush); + int bandWidth = 1; + if (stippled) { + bandWidth = 3; + byte [] bits = {-86, 0, 85, 0, -86, 0, 85, 0, -86, 0, 85, 0, -86, 0, 85, 0}; + hBitmap = OS.CreateBitmap (8, 8, 1, 1, bits); + hBrush = OS.CreatePatternBrush (hBitmap); + oldBrush = OS.SelectObject (hDC, hBrush); + OS.SetBkColor (hDC, 0xF0F0F0); + } else { + oldBrush = OS.SelectObject (hDC, OS.GetStockObject(OS.BLACK_BRUSH)); + } + Rectangle[] rects = this.rectangles; + RECT rect1 = new RECT (); + for (int i=0; i