Mercurial > projects > dwt-win
view dwt/widgets/Control.d @ 341:f403c83322c3 default tip
fix: thx torhu
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Sun, 08 Nov 2009 20:58:32 +0100 |
parents | 27479f54069d |
children |
line wrap: on
line source
/******************************************************************************* * Copyright (c) 2000, 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: * IBM Corporation - initial API and implementation * Port to the D programming language: * Frank Benoit <benoit@tionex.de> *******************************************************************************/ module dwt.widgets.Control; import dwt.DWT; import dwt.DWTException; import dwt.accessibility.Accessible; import dwt.events.ControlListener; import dwt.events.DragDetectListener; import dwt.events.FocusListener; import dwt.events.HelpListener; import dwt.events.KeyListener; import dwt.events.MenuDetectListener; import dwt.events.MouseEvent; import dwt.events.MouseListener; import dwt.events.MouseMoveListener; import dwt.events.MouseTrackListener; import dwt.events.MouseWheelListener; import dwt.events.PaintListener; import dwt.events.TraverseListener; import dwt.graphics.Color; import dwt.graphics.Cursor; import dwt.graphics.Drawable; import dwt.graphics.Font; import dwt.graphics.GC; import dwt.graphics.GCData; import dwt.graphics.Image; import dwt.graphics.Point; import dwt.graphics.Rectangle; import dwt.graphics.Region; import dwt.internal.win32.OS; import dwt.widgets.Widget; import dwt.widgets.Composite; import dwt.widgets.Dialog; import dwt.widgets.Event; import dwt.widgets.Shell; import dwt.widgets.Menu; import dwt.widgets.MenuItem; import dwt.widgets.Decorations; import dwt.widgets.TypedListener; import dwt.widgets.Listener; import dwt.widgets.Display; import dwt.widgets.Monitor; import dwt.dwthelper.utils; import dwt.dwthelper.System; static import tango.sys.Common; /** * Control is the abstract superclass of all windowed user interface classes. * <p> * <dl> * <dt><b>Styles:</b> * <dd>BORDER</dd> * <dd>LEFT_TO_RIGHT, RIGHT_TO_LEFT</dd> * <dt><b>Events:</b> * <dd>DragDetect, FocusIn, FocusOut, Help, KeyDown, KeyUp, MenuDetect, MouseDoubleClick, MouseDown, MouseEnter, * MouseExit, MouseHover, MouseUp, MouseMove, Move, Paint, Resize, Traverse</dd> * </dl> * </p><p> * Only one of LEFT_TO_RIGHT or RIGHT_TO_LEFT may be specified. * </p><p> * IMPORTANT: This class is intended to be subclassed <em>only</em> * within the DWT implementation. * </p> * * @see <a href="http://www.eclipse.org/swt/snippets/#control">Control snippets</a> * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Example: ControlExample</a> * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> */ public abstract class Control : Widget, Drawable { alias Widget.dragDetect dragDetect; alias Widget.callWindowProc callWindowProc; /** * the handle to the OS resource * (Warning: This field is platform dependent) * <p> * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT * public API. It is marked public only so that it can be shared * within the packages provided by DWT. It is not available on all * platforms and should never be accessed from application code. * </p> */ public HANDLE handle; Composite parent; Cursor cursor; Menu menu; String toolTipText_; Object layoutData; Accessible accessible; Image backgroundImage; Region region; Font font; int drawCount, foreground, background; /** * Prevents uninitialized instances from being created outside the package. */ this () { } /** * Constructs a new instance of this class given its parent * and a style value describing its behavior and appearance. * <p> * The style value is either one of the style constants defined in * class <code>DWT</code> which is applicable to instances of this * class, or must be built by <em>bitwise OR</em>'ing together * (that is, using the <code>int</code> "|" operator) two or more * of those <code>DWT</code> style constants. The class description * lists the style constants that are applicable to the class. * Style bits are also inherited from superclasses. * </p> * * @param parent a composite control which will be the parent of the new instance (cannot be null) * @param style the style of control to construct * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> * </ul> * * @see DWT#BORDER * @see Widget#checkSubclass * @see Widget#getStyle */ public this (Composite parent, int style) { super (parent, style); this.parent = parent; createWidget (); } /** * 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 <code>ControlListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see ControlListener * @see #removeControlListener */ public void addControlListener(ControlListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.Resize,typedListener); addListener (DWT.Move,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when a drag gesture occurs, by sending it * one of the messages defined in the <code>DragDetectListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see DragDetectListener * @see #removeDragDetectListener * * @since 3.3 */ public void addDragDetectListener (DragDetectListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.DragDetect,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when the control gains or loses focus, by sending * it one of the messages defined in the <code>FocusListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see FocusListener * @see #removeFocusListener */ public void addFocusListener (FocusListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.FocusIn,typedListener); addListener (DWT.FocusOut,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when help events are generated for the control, * by sending it one of the messages defined in the * <code>HelpListener</code> interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see HelpListener * @see #removeHelpListener */ public void addHelpListener (HelpListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.Help, 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 <code>KeyListener</code> * interface. * <p> * When a key listener is added to a control, the control * will take part in widget traversal. By default, all * traversal keys (such as the tab key and so on) are * delivered to the control. In order for a control to take * part in traversal, it should listen for traversal events. * Otherwise, the user can traverse into a control but not * out. Note that native controls such as table and tree * implement key traversal in the operating system. It is * not necessary to add traversal listeners for these controls, * unless you want to override the default traversal. * </p> * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see KeyListener * @see #removeKeyListener */ public void addKeyListener (KeyListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.KeyUp,typedListener); addListener (DWT.KeyDown,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when the platform-specific context menu trigger * has occurred, by sending it one of the messages defined in * the <code>MenuDetectListener</code> interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MenuDetectListener * @see #removeMenuDetectListener * * @since 3.3 */ public void addMenuDetectListener (MenuDetectListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.MenuDetect, typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when mouse buttons are pressed and released, by sending * it one of the messages defined in the <code>MouseListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseListener * @see #removeMouseListener */ public void addMouseListener (MouseListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.MouseDown,typedListener); addListener (DWT.MouseUp,typedListener); addListener (DWT.MouseDoubleClick,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when the mouse passes or hovers over controls, by sending * it one of the messages defined in the <code>MouseTrackListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseTrackListener * @see #removeMouseTrackListener */ public void addMouseTrackListener (MouseTrackListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.MouseEnter,typedListener); addListener (DWT.MouseExit,typedListener); addListener (DWT.MouseHover,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when the mouse moves, by sending it one of the * messages defined in the <code>MouseMoveListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseMoveListener * @see #removeMouseMoveListener */ public void addMouseMoveListener (MouseMoveListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.MouseMove,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when the mouse wheel is scrolled, by sending * it one of the messages defined in the * <code>MouseWheelListener</code> interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseWheelListener * @see #removeMouseWheelListener * * @since 3.3 */ public void addMouseWheelListener (MouseWheelListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.MouseWheel, typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when the receiver needs to be painted, by sending it * one of the messages defined in the <code>PaintListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see PaintListener * @see #removePaintListener */ public void addPaintListener (PaintListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.Paint,typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when traversal events occur, by sending it * one of the messages defined in the <code>TraverseListener</code> * interface. * * @param listener the listener which should be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see TraverseListener * @see #removeTraverseListener */ public void addTraverseListener (TraverseListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.Traverse,typedListener); } HANDLE borderHandle () { return handle; } void checkBackground () { Shell shell = getShell (); if (this is shell) return; state &= ~PARENT_BACKGROUND; Composite composite = parent; do { auto mode = composite.backgroundMode; if (mode !is 0) { if (mode is DWT.INHERIT_DEFAULT) { Control control = this; do { if ((control.state & THEME_BACKGROUND) is 0) { return; } control = control.parent; } while (control !is composite); } state |= PARENT_BACKGROUND; return; } if (composite is shell) break; composite = composite.parent; } while (true); } void checkBorder () { if (getBorderWidth () is 0) style &= ~DWT.BORDER; } void checkBuffered () { style &= ~DWT.DOUBLE_BUFFERED; } void checkComposited () { /* Do nothing */ } bool checkHandle (HWND hwnd) { return hwnd is handle; } void checkMirrored () { if ((style & DWT.RIGHT_TO_LEFT) !is 0) { int bits = OS.GetWindowLong (handle, OS.GWL_EXSTYLE); if ((bits & OS.WS_EX_LAYOUTRTL) !is 0) style |= DWT.MIRRORED; } } /** * Returns the preferred size of the receiver. * <p> * The <em>preferred size</em> of a control is the size that it would * best be displayed at. The width hint and height hint arguments * allow the caller to ask a control questions such as "Given a particular * width, how high does the control need to be to show all of the contents?" * To indicate that the caller does not wish to constrain a particular * dimension, the constant <code>DWT.DEFAULT</code> is passed for the hint. * </p> * * @param wHint the width hint (can be <code>DWT.DEFAULT</code>) * @param hHint the height hint (can be <code>DWT.DEFAULT</code>) * @return the preferred size of the control * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see Layout * @see #getBorderWidth * @see #getBounds * @see #getSize * @see #pack(bool) * @see "computeTrim, getClientArea for controls that implement them" */ public Point computeSize (int wHint, int hHint) { return computeSize (wHint, hHint, true); } /** * Returns the preferred size of the receiver. * <p> * The <em>preferred size</em> of a control is the size that it would * best be displayed at. The width hint and height hint arguments * allow the caller to ask a control questions such as "Given a particular * width, how high does the control need to be to show all of the contents?" * To indicate that the caller does not wish to constrain a particular * dimension, the constant <code>DWT.DEFAULT</code> is passed for the hint. * </p><p> * If the changed flag is <code>true</code>, it indicates that the receiver's * <em>contents</em> have changed, therefore any caches that a layout manager * containing the control may have been keeping need to be flushed. When the * control is resized, the changed flag will be <code>false</code>, so layout * manager caches can be retained. * </p> * * @param wHint the width hint (can be <code>DWT.DEFAULT</code>) * @param hHint the height hint (can be <code>DWT.DEFAULT</code>) * @param changed <code>true</code> if the control's contents have changed, and <code>false</code> otherwise * @return the preferred size of the control. * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see Layout * @see #getBorderWidth * @see #getBounds * @see #getSize * @see #pack(bool) * @see "computeTrim, getClientArea for controls that implement them" */ public Point computeSize (int wHint, int hHint, bool changed) { checkWidget (); int width = DEFAULT_WIDTH; int height = DEFAULT_HEIGHT; if (wHint !is DWT.DEFAULT) width = wHint; if (hHint !is DWT.DEFAULT) height = hHint; int border = getBorderWidth (); width += border * 2; height += border * 2; return new Point (width, height); } Control computeTabGroup () { if (isTabGroup ()) return this; return parent.computeTabGroup (); } Control computeTabRoot () { Control [] tabList = parent._getTabList (); if (tabList !is null) { int index = 0; while (index < tabList.length) { if (tabList [index] is this) break; index++; } if (index is tabList.length) { if (isTabGroup ()) return this; } } return parent.computeTabRoot (); } Control [] computeTabList () { if (isTabGroup ()) { if (getVisible () && getEnabled ()) { return [this]; } } return new Control [0]; } void createHandle () { auto hwndParent = widgetParent (); handle = OS.CreateWindowEx ( widgetExtStyle (), StrToTCHARz( windowClass () ), null, widgetStyle (), OS.CW_USEDEFAULT, 0, OS.CW_USEDEFAULT, 0, hwndParent, null, OS.GetModuleHandle (null), widgetCreateStruct ()); if (handle is null) error (DWT.ERROR_NO_HANDLES); int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); if ((bits & OS.WS_CHILD) !is 0) { OS.SetWindowLongPtr (handle, OS.GWLP_ID, cast(LONG_PTR)handle); } if (OS.IsDBLocale && hwndParent !is null) { auto hIMC = OS.ImmGetContext (hwndParent); OS.ImmAssociateContext (handle, hIMC); OS.ImmReleaseContext (hwndParent, hIMC); } } void createWidget () { state |= DRAG_DETECT; foreground = background = -1; checkOrientation (parent); createHandle (); checkBackground (); checkBuffered (); checkComposited (); register (); subclass (); setDefaultFont (); checkMirrored (); checkBorder (); if ((state & PARENT_BACKGROUND) !is 0) { setBackground (); } } int defaultBackground () { static if (OS.IsWinCE) return OS.GetSysColor (OS.COLOR_WINDOW); return OS.GetSysColor (OS.COLOR_BTNFACE); } HFONT defaultFont () { return display.getSystemFont ().handle; } int defaultForeground () { return OS.GetSysColor (OS.COLOR_WINDOWTEXT); } void deregister () { display.removeControl (handle); } override void destroyWidget () { auto hwnd = topHandle (); releaseHandle (); if (hwnd !is null) { OS.DestroyWindow (hwnd); } } /** * Detects a drag and drop gesture. This method is used * to detect a drag gesture when called from within a mouse * down listener. * * <p>By default, a drag is detected when the gesture * occurs anywhere within the client area of a control. * Some controls, such as tables and trees, override this * behavior. In addition to the operating system specific * drag gesture, they require the mouse to be inside an * item. Custom widget writers can use <code>setDragDetect</code> * to disable the default detection, listen for mouse down, * and then call <code>dragDetect()</code> from within the * listener to conditionally detect a drag. * </p> * * @param event the mouse down event * * @return <code>true</code> if the gesture occurred, and <code>false</code> otherwise. * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT when the event is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see DragDetectListener * @see #addDragDetectListener * * @see #getDragDetect * @see #setDragDetect * * @since 3.3 */ public bool dragDetect (Event event) { checkWidget (); if (event is null) error (DWT.ERROR_NULL_ARGUMENT); return dragDetect (event.button, event.count, event.stateMask, event.x, event.y); } /** * Detects a drag and drop gesture. This method is used * to detect a drag gesture when called from within a mouse * down listener. * * <p>By default, a drag is detected when the gesture * occurs anywhere within the client area of a control. * Some controls, such as tables and trees, override this * behavior. In addition to the operating system specific * drag gesture, they require the mouse to be inside an * item. Custom widget writers can use <code>setDragDetect</code> * to disable the default detection, listen for mouse down, * and then call <code>dragDetect()</code> from within the * listener to conditionally detect a drag. * </p> * * @param event the mouse down event * * @return <code>true</code> if the gesture occurred, and <code>false</code> otherwise. * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT when the event is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see DragDetectListener * @see #addDragDetectListener * * @see #getDragDetect * @see #setDragDetect * * @since 3.3 */ public bool dragDetect (MouseEvent event) { checkWidget (); if (event is null) error (DWT.ERROR_NULL_ARGUMENT); return dragDetect (event.button, event.count, event.stateMask, event.x, event.y); } bool dragDetect (int button, int count, int stateMask, int x, int y) { if (button !is 1 || count !is 1) return false; bool dragging = dragDetect (handle, x, y, false, null, null); if (OS.GetKeyState (OS.VK_LBUTTON) < 0) { if (OS.GetCapture () !is handle) OS.SetCapture (handle); } if (!dragging) { /* * Feature in Windows. DragDetect() captures the mouse * and tracks its movement until the user releases the * left mouse button, presses the ESC key, or moves the * mouse outside the drag rectangle. If the user moves * the mouse outside of the drag rectangle, DragDetect() * returns true and a drag and drop operation can be * started. When the left mouse button is released or * the ESC key is pressed, these events are consumed by * DragDetect() so that application code that matches * mouse down/up pairs or looks for the ESC key will not * function properly. The fix is to send the missing * events when the drag has not started. * * NOTE: For now, don't send a fake WM_KEYDOWN/WM_KEYUP * events for the ESC key. This would require computing * wParam (the key) and lParam (the repeat count, scan code, * extended-key flag, context code, previous key-state flag, * and transition-state flag) which is non-trivial. */ if (button is 1 && OS.GetKeyState (OS.VK_ESCAPE) >= 0) { int wParam = 0; if ((stateMask & DWT.CTRL) !is 0) wParam |= OS.MK_CONTROL; if ((stateMask & DWT.SHIFT) !is 0) wParam |= OS.MK_SHIFT; if ((stateMask & DWT.ALT) !is 0) wParam |= OS.MK_ALT; if ((stateMask & DWT.BUTTON1) !is 0) wParam |= OS.MK_LBUTTON; if ((stateMask & DWT.BUTTON2) !is 0) wParam |= OS.MK_MBUTTON; if ((stateMask & DWT.BUTTON3) !is 0) wParam |= OS.MK_RBUTTON; if ((stateMask & DWT.BUTTON4) !is 0) wParam |= OS.MK_XBUTTON1; if ((stateMask & DWT.BUTTON5) !is 0) wParam |= OS.MK_XBUTTON2; int /*long*/ lParam = OS.MAKELPARAM (x, y); OS.SendMessage (handle, OS.WM_LBUTTONUP, wParam, lParam); } return false; } return sendDragEvent (button, stateMask, x, y); } void drawBackground (HDC hDC) { RECT rect; OS.GetClientRect (handle, &rect); drawBackground (hDC, &rect); } void drawBackground (HDC hDC, RECT* rect) { drawBackground (hDC, rect, -1); } void drawBackground (HDC hDC, RECT* rect, int pixel) { Control control = findBackgroundControl (); if (control !is null) { if (control.backgroundImage !is null) { fillImageBackground (hDC, control, rect); return; } pixel = control.getBackgroundPixel (); } if (pixel is -1) { if ((state & THEME_BACKGROUND) !is 0) { if (OS.COMCTL32_MAJOR >= 6 && OS.IsAppThemed ()) { control = findThemeControl (); if (control !is null) { fillThemeBackground (hDC, control, rect); return; } } } } if (pixel is -1) pixel = getBackgroundPixel (); fillBackground (hDC, pixel, rect); } void drawImageBackground (HDC hDC, HWND hwnd, HBITMAP hBitmap, RECT* rect) { RECT rect2; OS.GetClientRect (hwnd, &rect2); OS.MapWindowPoints (hwnd, handle, cast(POINT*)&rect2, 2); auto hBrush = findBrush ( cast(int)hBitmap, OS.BS_PATTERN); POINT lpPoint; OS.GetWindowOrgEx (hDC, &lpPoint); OS.SetBrushOrgEx (hDC, -rect2.left - lpPoint.x, -rect2.top - lpPoint.y, &lpPoint); auto hOldBrush = OS.SelectObject (hDC, hBrush); OS.PatBlt (hDC, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, OS.PATCOPY); OS.SetBrushOrgEx (hDC, lpPoint.x, lpPoint.y, null); OS.SelectObject (hDC, hOldBrush); } void drawThemeBackground (HDC hDC, HWND hwnd, RECT* rect) { /* Do nothing */ } void enableDrag (bool enabled) { /* Do nothing */ } void enableWidget (bool enabled) { OS.EnableWindow (handle, enabled); } void fillBackground (HDC hDC, int pixel, RECT* rect) { if (rect.left > rect.right || rect.top > rect.bottom) return; auto hPalette = display.hPalette; if (hPalette !is null) { OS.SelectPalette (hDC, hPalette, false); OS.RealizePalette (hDC); } OS.FillRect (hDC, rect, findBrush (pixel, OS.BS_SOLID)); } void fillImageBackground (HDC hDC, Control control, RECT* rect) { if (rect.left > rect.right || rect.top > rect.bottom) return; if (control !is null) { Image image = control.backgroundImage; if (image !is null) { control.drawImageBackground (hDC, handle, image.handle, rect); } } } void fillThemeBackground (HDC hDC, Control control, RECT* rect) { if (rect.left > rect.right || rect.top > rect.bottom) return; if (control !is null) { control.drawThemeBackground (hDC, handle, rect); } } Control findBackgroundControl () { if (background !is -1 || backgroundImage !is null) return this; return (state & PARENT_BACKGROUND) !is 0 ? parent.findBackgroundControl () : null; } HBRUSH findBrush (int value, int lbStyle) { return parent.findBrush (value, lbStyle); } Cursor findCursor () { if (cursor !is null) return cursor; return parent.findCursor (); } Control findImageControl () { Control control = findBackgroundControl (); return control !is null && control.backgroundImage !is null ? control : null; } Control findThemeControl () { return background is -1 && backgroundImage is null ? parent.findThemeControl () : null; } Menu [] findMenus (Control control) { if (menu !is null && this !is control) return [menu]; return new Menu [0]; } char findMnemonic (String string) { int index = 0; int length_ = string.length; do { while (index < length_ && string.charAt (index) !is '&') index++; if (++index >= length_) return '\0'; if (string.charAt (index) !is '&') return string.charAt (index); index++; } while (index < length_); return '\0'; } void fixChildren (Shell newShell, Shell oldShell, Decorations newDecorations, Decorations oldDecorations, Menu [] menus) { oldShell.fixShell (newShell, this); oldDecorations.fixDecorations (newDecorations, this, menus); } void fixFocus (Control focusControl) { Shell shell = getShell (); Control control = this; while (control !is shell && (control = control.parent) !is null) { if (control.setFixedFocus ()) return; } shell.setSavedFocus (focusControl); OS.SetFocus (null); } /** * Forces the receiver to have the <em>keyboard focus</em>, causing * all keyboard events to be delivered to it. * * @return <code>true</code> if the control got focus, and <code>false</code> if it was unable to. * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #setFocus */ public bool forceFocus () { checkWidget (); if (display.focusEvent is DWT.FocusOut) return false; Decorations shell = menuShell (); shell.setSavedFocus (this); if (!isEnabled () || !isVisible () || !isActive ()) return false; if (isFocusControl ()) return true; shell.setSavedFocus (null); /* * This code is intentionally commented. * * When setting focus to a control, it is * possible that application code can set * the focus to another control inside of * WM_SETFOCUS. In this case, the original * control will no longer have the focus * and the call to setFocus() will return * false indicating failure. * * We are still working on a solution at * this time. */ // if (OS.GetFocus () !is OS.SetFocus (handle)) return false; OS.SetFocus (handle); if (isDisposed ()) return false; shell.setSavedFocus (this); return isFocusControl (); } void forceResize () { if (parent is null) return; WINDOWPOS*[] lpwp = parent.lpwp; if (lpwp is null) return; for (int i=0; i<lpwp.length; i++) { WINDOWPOS* wp = lpwp [i]; if (wp !is null && wp._hwnd is handle) { /* * This code is intentionally commented. All widgets that * are created by DWT have WS_CLIPSIBLINGS to ensure that * application code does not draw outside of the control. */ // int count = parent.getChildrenCount (); // if (count > 1) { // int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); // if ((bits & OS.WS_CLIPSIBLINGS) is 0) wp.flags |= OS.SWP_NOCOPYBITS; // } SetWindowPos (wp._hwnd, null, wp.x, wp.y, wp.cx, wp.cy, wp.flags); lpwp [i] = null; return; } } } /** * Returns the accessible object for the receiver. * If this is the first time this object is requested, * then the object is created and returned. * * @return the accessible object * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see Accessible#addAccessibleListener * @see Accessible#addAccessibleControlListener * * @since 2.0 */ public Accessible getAccessible () { checkWidget (); if (accessible is null) accessible = new_Accessible (this); return accessible; } /** * Returns the receiver's background color. * * @return the background color * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Color getBackground () { checkWidget (); Control control = findBackgroundControl (); if (control is null) control = this; return Color.win32_new (display, control.getBackgroundPixel ()); } /** * Returns the receiver's background image. * * @return the background image * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.2 */ public Image getBackgroundImage () { checkWidget (); Control control = findBackgroundControl (); if (control is null) control = this; return control.backgroundImage; } int getBackgroundPixel () { return background !is -1 ? background : defaultBackground (); } /** * Returns the receiver's border width. * * @return the border width * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public int getBorderWidth () { checkWidget (); auto borderHandle = borderHandle (); int bits1 = OS.GetWindowLong (borderHandle, OS.GWL_EXSTYLE); if ((bits1 & OS.WS_EX_CLIENTEDGE) !is 0) return OS.GetSystemMetrics (OS.SM_CXEDGE); if ((bits1 & OS.WS_EX_STATICEDGE) !is 0) return OS.GetSystemMetrics (OS.SM_CXBORDER); int bits2 = OS.GetWindowLong (borderHandle, OS.GWL_STYLE); if ((bits2 & OS.WS_BORDER) !is 0) return OS.GetSystemMetrics (OS.SM_CXBORDER); return 0; } /** * Returns a rectangle describing the receiver's size and location * relative to its parent (or its display if its parent is null), * unless the receiver is a shell. In this case, the location is * relative to the display. * * @return the receiver's bounding rectangle * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Rectangle getBounds () { checkWidget (); forceResize (); RECT rect; OS.GetWindowRect (topHandle (), &rect); auto hwndParent = parent is null ? null : parent.handle; OS.MapWindowPoints (null, hwndParent, cast(POINT*)&rect, 2); int width = rect.right - rect.left; int height = rect.bottom - rect.top; return new Rectangle (rect.left, rect.top, width, height); } int getCodePage () { if (OS.IsUnicode) return OS.CP_ACP; auto hFont = cast(HFONT) OS.SendMessage (handle, OS.WM_GETFONT, 0, 0); LOGFONT logFont; OS.GetObject (hFont, LOGFONT.sizeof, &logFont); int cs = logFont.lfCharSet & 0xFF; int [] lpCs = new int [8]; if (OS.TranslateCharsetInfo (cast(uint*)cs, cast(CHARSETINFO*)lpCs.ptr, OS.TCI_SRCCHARSET)) { return lpCs [1]; } return OS.GetACP (); } String getClipboardText () { String string = ""; if (OS.OpenClipboard (null)) { auto hMem = OS.GetClipboardData (OS.IsUnicode ? OS.CF_UNICODETEXT : OS.CF_TEXT); if (hMem !is null) { /* Ensure byteCount is a multiple of 2 bytes on UNICODE platforms */ int byteCount = OS.GlobalSize (hMem) / TCHAR.sizeof * TCHAR.sizeof; auto ptr = OS.GlobalLock (hMem); if (ptr !is null) { /* Use the character encoding for the default locale */ string = TCHARzToStr( cast(TCHAR*)ptr ); OS.GlobalUnlock (hMem); } } OS.CloseClipboard (); } return string; } /** * Returns the receiver's cursor, or null if it has not been set. * <p> * When the mouse pointer passes over a control its appearance * is changed to match the control's cursor. * </p> * * @return the receiver's cursor or <code>null</code> * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.3 */ public Cursor getCursor () { checkWidget (); return cursor; } /** * Returns <code>true</code> if the receiver is detecting * drag gestures, and <code>false</code> otherwise. * * @return the receiver's drag detect state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.3 */ public bool getDragDetect () { checkWidget (); return (state & DRAG_DETECT) !is 0; } /** * Returns <code>true</code> if the receiver is enabled, and * <code>false</code> otherwise. A disabled control is typically * not selectable from the user interface and draws with an * inactive or "grayed" look. * * @return the receiver's enabled state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #isEnabled */ public bool getEnabled () { checkWidget (); return cast(bool)OS.IsWindowEnabled (handle); } /** * Returns the font that the receiver will use to paint textual information. * * @return the receiver's font * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Font getFont () { checkWidget (); if (font !is null) return font; auto hFont = cast(HFONT)OS.SendMessage (handle, OS.WM_GETFONT, 0, 0); if (hFont is null) hFont = defaultFont (); return Font.win32_new (display, hFont); } /** * Returns the foreground color that the receiver will use to draw. * * @return the receiver's foreground color * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Color getForeground () { checkWidget (); return Color.win32_new (display, getForegroundPixel ()); } int getForegroundPixel () { return foreground !is -1 ? foreground : defaultForeground (); } /** * Returns layout data which is associated with the receiver. * * @return the receiver's layout data * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Object getLayoutData () { checkWidget (); return layoutData; } /** * Returns a point describing the receiver's location relative * to its parent (or its display if its parent is null), unless * the receiver is a shell. In this case, the point is * relative to the display. * * @return the receiver's location * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Point getLocation () { checkWidget (); forceResize (); RECT rect; OS.GetWindowRect (topHandle (), &rect); auto hwndParent = parent is null ? null : parent.handle; OS.MapWindowPoints (null, hwndParent, cast(POINT*)&rect, 2); return new Point (rect.left, rect.top); } /** * Returns the receiver's pop up menu if it has one, or null * if it does not. All controls may optionally have a pop up * menu that is displayed when the user requests one for * the control. The sequence of key strokes, button presses * and/or button releases that are used to request a pop up * menu is platform specific. * * @return the receiver's menu * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ override public Menu getMenu () { checkWidget (); return menu; } /** * Returns the receiver's monitor. * * @return the receiver's monitor * * @since 3.0 */ public dwt.widgets.Monitor.Monitor getMonitor () { checkWidget (); if (OS.IsWinCE || OS.WIN32_VERSION < OS.VERSION (4, 10)) { return display.getPrimaryMonitor (); } auto hmonitor = OS.MonitorFromWindow (handle, OS.MONITOR_DEFAULTTONEAREST); MONITORINFO lpmi; lpmi.cbSize = MONITORINFO.sizeof; OS.GetMonitorInfo (hmonitor, &lpmi); dwt.widgets.Monitor.Monitor monitor = new dwt.widgets.Monitor.Monitor (); monitor.handle = hmonitor; monitor.x = lpmi.rcMonitor.left; monitor.y = lpmi.rcMonitor.top; monitor.width = lpmi.rcMonitor.right - lpmi.rcMonitor.left; monitor.height = lpmi.rcMonitor.bottom - lpmi.rcMonitor.top; monitor.clientX = lpmi.rcWork.left; monitor.clientY = lpmi.rcWork.top; monitor.clientWidth = lpmi.rcWork.right - lpmi.rcWork.left; monitor.clientHeight = lpmi.rcWork.bottom - lpmi.rcWork.top; return monitor; } /** * Returns the receiver's parent, which must be a <code>Composite</code> * or null when the receiver is a shell that was created with null or * a display for a parent. * * @return the receiver's parent * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Composite getParent () { checkWidget (); return parent; } Control [] getPath () { int count = 0; Shell shell = getShell (); Control control = this; while (control !is shell) { count++; control = control.parent; } control = this; Control [] result = new Control [count]; while (control !is shell) { result [--count] = control; control = control.parent; } return result; } /** * Returns the region that defines the shape of the control, * or null if the control has the default shape. * * @return the region that defines the shape of the shell (or null) * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.4 */ public Region getRegion () { checkWidget (); return region; } /** * Returns the receiver's shell. For all controls other than * shells, this simply returns the control's nearest ancestor * shell. Shells return themselves, even if they are children * of other shells. * * @return the receiver's shell * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #getParent */ public Shell getShell () { checkWidget (); return parent.getShell (); } /** * Returns a point describing the receiver's size. The * x coordinate of the result is the width of the receiver. * The y coordinate of the result is the height of the * receiver. * * @return the receiver's size * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Point getSize () { checkWidget (); forceResize (); RECT rect; OS.GetWindowRect (topHandle (), &rect); int width = rect.right - rect.left; int height = rect.bottom - rect.top; return new Point (width, height); } /** * Returns the receiver's tool tip text, or null if it has * not been set. * * @return the receiver's tool tip text * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public String getToolTipText () { checkWidget (); return toolTipText_; } /** * Returns <code>true</code> if the receiver is visible, and * <code>false</code> otherwise. * <p> * If one of the receiver's ancestors is not visible or some * other condition makes the receiver not visible, this method * may still indicate that it is considered visible even though * it may not actually be showing. * </p> * * @return the receiver's visibility state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public bool getVisible () { checkWidget (); if (drawCount !is 0) return (state & HIDDEN) is 0; int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); return (bits & OS.WS_VISIBLE) !is 0; } bool hasCursor () { RECT rect; if (!OS.GetClientRect (handle, &rect)) return false; OS.MapWindowPoints (handle, null, cast(POINT*)&rect, 2); POINT pt; return OS.GetCursorPos (&pt) && OS.PtInRect (&rect, pt); } bool hasFocus () { /* * If a non-DWT child of the control has focus, * then this control is considered to have focus * even though it does not have focus in Windows. */ auto hwndFocus = OS.GetFocus (); while (hwndFocus !is null) { if (hwndFocus is handle) return true; if (display.getControl (hwndFocus) !is null) { return false; } hwndFocus = OS.GetParent (hwndFocus); } return false; } /** * Invokes platform specific functionality to allocate a new GC handle. * <p> * <b>IMPORTANT:</b> This method is <em>not</em> part of the public * API for <code>Control</code>. It is marked public only so that it * can be shared within the packages provided by DWT. It is not * available on all platforms, and should never be called from * application code. * </p> * * @param data the platform specific GC data * @return the platform specific GC handle */ public HDC internal_new_GC (GCData data) { checkWidget(); auto hwnd = handle; if (data !is null && data.hwnd !is null) hwnd = data.hwnd; if (data !is null) data.hwnd = hwnd; HDC hDC; if (data is null || data.ps is null) { hDC = OS.GetDC (hwnd); } else { hDC = OS.BeginPaint (hwnd, data.ps); } if (hDC is null) DWT.error(DWT.ERROR_NO_HANDLES); if (data !is null) { if (!OS.IsWinCE && OS.WIN32_VERSION >= OS.VERSION (4, 10)) { int mask = DWT.LEFT_TO_RIGHT | DWT.RIGHT_TO_LEFT; if ((data.style & mask) !is 0) { data.layout = (data.style & DWT.RIGHT_TO_LEFT) !is 0 ? OS.LAYOUT_RTL : 0; } else { int flags = OS.GetLayout (hDC); if ((flags & OS.LAYOUT_RTL) !is 0) { data.style |= DWT.RIGHT_TO_LEFT | DWT.MIRRORED; } else { data.style |= DWT.LEFT_TO_RIGHT; } } } else { data.style |= DWT.LEFT_TO_RIGHT; } data.device = display; auto foreground = getForegroundPixel (); if (foreground !is OS.GetTextColor (hDC)) data.foreground = foreground; Control control = findBackgroundControl (); if (control is null) control = this; auto background = control.getBackgroundPixel (); if (background !is OS.GetBkColor (hDC)) data.background = background; data.font = font !is null ? font : Font.win32_new (display, cast(HFONT)OS.SendMessage (hwnd, OS.WM_GETFONT, 0, 0)); data.uiState = OS.SendMessage (hwnd, OS.WM_QUERYUISTATE, 0, 0); } return hDC; } /** * Invokes platform specific functionality to dispose a GC handle. * <p> * <b>IMPORTANT:</b> This method is <em>not</em> part of the public * API for <code>Control</code>. It is marked public only so that it * can be shared within the packages provided by DWT. It is not * available on all platforms, and should never be called from * application code. * </p> * * @param hDC the platform specific GC handle * @param data the platform specific GC data */ public void internal_dispose_GC (HDC hDC, GCData data) { checkWidget (); auto hwnd = handle; if (data !is null && data.hwnd !is null) { hwnd = data.hwnd; } if (data is null || data.ps is null) { OS.ReleaseDC (hwnd, hDC); } else { OS.EndPaint (hwnd, data.ps); } } bool isActive () { Dialog dialog = display.getModalDialog (); if (dialog !is null) { Shell dialogShell = dialog.parent; if (dialogShell !is null && !dialogShell.isDisposed ()) { if (dialogShell !is getShell ()) return false; } } Shell shell = null; Shell [] modalShells = display.modalShells; if (modalShells !is null) { int bits = DWT.APPLICATION_MODAL | DWT.SYSTEM_MODAL; int index = modalShells.length; while (--index >= 0) { Shell modal = modalShells [index]; if (modal !is null) { if ((modal.style & bits) !is 0) { Control control = this; while (control !is null) { if (control is modal) break; control = control.parent; } if (control !is modal) return false; break; } if ((modal.style & DWT.PRIMARY_MODAL) !is 0) { if (shell is null) shell = getShell (); if (modal.parent is shell) return false; } } } } if (shell is null) shell = getShell (); return shell.getEnabled (); } /** * Returns <code>true</code> if the receiver is enabled and all * ancestors up to and including the receiver's nearest ancestor * shell are enabled. Otherwise, <code>false</code> is returned. * A disabled control is typically not selectable from the user * interface and draws with an inactive or "grayed" look. * * @return the receiver's enabled state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #getEnabled */ public bool isEnabled () { checkWidget (); return getEnabled () && parent.isEnabled (); } /** * Returns <code>true</code> if the receiver has the user-interface * focus, and <code>false</code> otherwise. * * @return the receiver's focus state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public bool isFocusControl () { checkWidget (); Control focusControl = display.focusControl; if (focusControl !is null && !focusControl.isDisposed ()) { return this is focusControl; } return hasFocus (); } bool isFocusAncestor (Control control) { while (control !is null && control !is this && !(cast(Shell)control )) { control = control.parent; } return control is this; } /** * Returns <code>true</code> if the underlying operating * system supports this reparenting, otherwise <code>false</code> * * @return <code>true</code> if the widget can be reparented, otherwise <code>false</code> * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public bool isReparentable () { checkWidget (); return true; } bool isShowing () { /* * This is not complete. Need to check if the * widget is obscured by a parent or sibling. */ if (!isVisible ()) return false; Control control = this; while (control !is null) { Point size = control.getSize (); if (size.x is 0 || size.y is 0) { return false; } control = control.parent; } return true; /* * Check to see if current damage is included. */ // if (!OS.IsWindowVisible (handle)) return false; // int flags = OS.DCX_CACHE | OS.DCX_CLIPCHILDREN | OS.DCX_CLIPSIBLINGS; // int /*long*/ hDC = OS.GetDCEx (handle, 0, flags); // int result = OS.GetClipBox (hDC, new RECT ()); // OS.ReleaseDC (handle, hDC); // return result !is OS.NULLREGION; } bool isTabGroup () { Control [] tabList = parent._getTabList (); if (tabList !is null) { for (int i=0; i<tabList.length; i++) { if (tabList [i] is this) return true; } } int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); return (bits & OS.WS_TABSTOP) !is 0; } bool isTabItem () { Control [] tabList = parent._getTabList (); if (tabList !is null) { for (int i=0; i<tabList.length; i++) { if (tabList [i] is this) return false; } } int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); if ((bits & OS.WS_TABSTOP) !is 0) return false; int /*long*/ code = OS.SendMessage (handle, OS.WM_GETDLGCODE, 0, 0); if ((code & OS.DLGC_STATIC) !is 0) return false; if ((code & OS.DLGC_WANTALLKEYS) !is 0) return false; if ((code & OS.DLGC_WANTARROWS) !is 0) return false; if ((code & OS.DLGC_WANTTAB) !is 0) return false; return true; } /** * Returns <code>true</code> if the receiver is visible and all * ancestors up to and including the receiver's nearest ancestor * shell are visible. Otherwise, <code>false</code> is returned. * * @return the receiver's visibility state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #getVisible */ public bool isVisible () { checkWidget (); if (OS.IsWindowVisible (handle)) return true; return getVisible () && parent.isVisible (); } override void mapEvent (HWND hwnd, Event event) { if (hwnd !is handle) { POINT point; point.x = event.x; point.y = event.y; OS.MapWindowPoints (hwnd, handle, &point, 1); event.x = point.x; event.y = point.y; } } void markLayout (bool changed, bool all) { /* Do nothing */ } Decorations menuShell () { return parent.menuShell (); } bool mnemonicHit (wchar key) { return false; } bool mnemonicMatch (wchar key) { return false; } /** * Moves the receiver above the specified control in the * drawing order. If the argument is null, then the receiver * is moved to the top of the drawing order. The control at * the top of the drawing order will not be covered by other * controls even if they occupy intersecting areas. * * @param control the sibling control (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the control has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see Control#moveBelow * @see Composite#getChildren */ public void moveAbove (Control control) { checkWidget (); auto topHandle_ = topHandle (); HWND hwndAbove = cast(HWND) OS.HWND_TOP; if (control !is null) { if (control.isDisposed ()) error(DWT.ERROR_INVALID_ARGUMENT); if (parent !is control.parent) return; auto hwnd = control.topHandle (); if (hwnd is null || hwnd is topHandle_) return; hwndAbove = OS.GetWindow (hwnd, OS.GW_HWNDPREV); /* * Bug in Windows. For some reason, when GetWindow () * with GW_HWNDPREV is used to query the previous window * in the z-order with the first child, Windows returns * the first child instead of NULL. The fix is to detect * this case and move the control to the top. */ if (hwndAbove is null || hwndAbove is hwnd) { hwndAbove = cast(HWND) OS.HWND_TOP; } } int flags = OS.SWP_NOSIZE | OS.SWP_NOMOVE | OS.SWP_NOACTIVATE; SetWindowPos (topHandle_, hwndAbove, 0, 0, 0, 0, flags); } /** * Moves the receiver below the specified control in the * drawing order. If the argument is null, then the receiver * is moved to the bottom of the drawing order. The control at * the bottom of the drawing order will be covered by all other * controls which occupy intersecting areas. * * @param control the sibling control (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the control has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see Control#moveAbove * @see Composite#getChildren */ public void moveBelow (Control control) { checkWidget (); auto topHandle_ = topHandle (); HWND hwndAbove = cast(HWND)OS.HWND_BOTTOM; if (control !is null) { if (control.isDisposed ()) error(DWT.ERROR_INVALID_ARGUMENT); if (parent !is control.parent) return; hwndAbove = control.topHandle (); } else { /* * Bug in Windows. When SetWindowPos() is called * with HWND_BOTTOM on a dialog shell, the dialog * and the parent are moved to the bottom of the * desktop stack. The fix is to move the dialog * to the bottom of the dialog window stack by * moving behind the first dialog child. */ Shell shell = getShell (); if (this is shell && parent !is null) { /* * Bug in Windows. For some reason, when GetWindow () * with GW_HWNDPREV is used to query the previous window * in the z-order with the first child, Windows returns * the first child instead of NULL. The fix is to detect * this case and do nothing because the control is already * at the bottom. */ auto hwndParent = parent.handle; auto hwnd = hwndParent; hwndAbove = OS.GetWindow (hwnd, OS.GW_HWNDPREV); while (hwndAbove !is null && hwndAbove !is hwnd) { if (OS.GetWindow (hwndAbove, OS.GW_OWNER) is hwndParent) break; hwndAbove = OS.GetWindow (hwnd = hwndAbove, OS.GW_HWNDPREV); } if (hwndAbove is hwnd) return; } } if (hwndAbove is null || hwndAbove is topHandle_) return; int flags = OS.SWP_NOSIZE | OS.SWP_NOMOVE | OS.SWP_NOACTIVATE; SetWindowPos (topHandle_, hwndAbove, 0, 0, 0, 0, flags); } Accessible new_Accessible (Control control) { return Accessible.internal_new_Accessible (this); } override GC new_GC (GCData data) { return GC.win32_new (this, data); } /** * Causes the receiver to be resized to its preferred size. * For a composite, this involves computing the preferred size * from its layout, if there is one. * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #computeSize(int, int, bool) */ public void pack () { checkWidget (); pack (true); } /** * Causes the receiver to be resized to its preferred size. * For a composite, this involves computing the preferred size * from its layout, if there is one. * <p> * If the changed flag is <code>true</code>, it indicates that the receiver's * <em>contents</em> have changed, therefore any caches that a layout manager * containing the control may have been keeping need to be flushed. When the * control is resized, the changed flag will be <code>false</code>, so layout * manager caches can be retained. * </p> * * @param changed whether or not the receiver's contents have changed * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #computeSize(int, int, bool) */ public void pack (bool changed) { checkWidget (); setSize (computeSize (DWT.DEFAULT, DWT.DEFAULT, changed)); } /** * Prints the receiver and all children. * * @param gc the gc where the drawing occurs * @return <code>true</code> if the operation was successful and <code>false</code> otherwise * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the gc is null</li> * <li>ERROR_INVALID_ARGUMENT - if the gc has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.4 */ public bool print (GC gc) { checkWidget (); if (gc is null) error (DWT.ERROR_NULL_ARGUMENT); if (gc.isDisposed ()) error (DWT.ERROR_INVALID_ARGUMENT); if (!OS.IsWinCE && OS.WIN32_VERSION >= OS.VERSION (5, 1)) { auto topHandle = topHandle (); int bits = OS.GetWindowLong (topHandle, OS.GWL_STYLE); if ((bits & OS.WS_VISIBLE) is 0) { OS.DefWindowProc (topHandle, OS.WM_SETREDRAW, 1, 0); } printWidget (topHandle, gc); if ((bits & OS.WS_VISIBLE) is 0) { OS.DefWindowProc (topHandle, OS.WM_SETREDRAW, 0, 0); } return true; } return false; } void printWidget (HWND hwnd, GC gc) { OS.PrintWindow (hwnd, gc.handle, 0); } /** * Causes the entire bounds of the receiver to be marked * as needing to be redrawn. The next time a paint request * is processed, the control will be completely painted, * including the background. * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #update() * @see PaintListener * @see DWT#Paint * @see DWT#NO_BACKGROUND * @see DWT#NO_REDRAW_RESIZE * @see DWT#NO_MERGE_PAINTS * @see DWT#DOUBLE_BUFFERED */ public void redraw () { checkWidget (); redraw (false); } void redraw (bool all) { // checkWidget (); if (!OS.IsWindowVisible (handle)) return; static if (OS.IsWinCE) { OS.InvalidateRect (handle, null, true); } else { int flags = OS.RDW_ERASE | OS.RDW_FRAME | OS.RDW_INVALIDATE; if (all) flags |= OS.RDW_ALLCHILDREN; OS.RedrawWindow (handle, null, null, flags); } } /** * Causes the rectangular area of the receiver specified by * the arguments to be marked as needing to be redrawn. * The next time a paint request is processed, that area of * the receiver will be painted, including the background. * If the <code>all</code> flag is <code>true</code>, any * children of the receiver which intersect with the specified * area will also paint their intersecting areas. If the * <code>all</code> flag is <code>false</code>, the children * will not be painted. * * @param x the x coordinate of the area to draw * @param y the y coordinate of the area to draw * @param width the width of the area to draw * @param height the height of the area to draw * @param all <code>true</code> if children should redraw, and <code>false</code> otherwise * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #update() * @see PaintListener * @see DWT#Paint * @see DWT#NO_BACKGROUND * @see DWT#NO_REDRAW_RESIZE * @see DWT#NO_MERGE_PAINTS * @see DWT#DOUBLE_BUFFERED */ public void redraw (int x, int y, int width, int height, bool all) { checkWidget (); if (width <= 0 || height <= 0) return; if (!OS.IsWindowVisible (handle)) return; RECT rect; OS.SetRect (&rect, x, y, x + width, y + height); static if (OS.IsWinCE) { OS.InvalidateRect (handle, &rect, true); } else { int flags = OS.RDW_ERASE | OS.RDW_FRAME | OS.RDW_INVALIDATE; if (all) flags |= OS.RDW_ALLCHILDREN; OS.RedrawWindow (handle, &rect, null, flags); } } bool redrawChildren () { if (!OS.IsWindowVisible (handle)) return false; Control control = findBackgroundControl (); if (control is null) { if ((state & THEME_BACKGROUND) !is 0) { if (OS.COMCTL32_MAJOR >= 6 && OS.IsAppThemed ()) { OS.InvalidateRect (handle, null, true); return true; } } } else { if (control.backgroundImage !is null) { OS.InvalidateRect (handle, null, true); return true; } } return false; } void register () { display.addControl (handle, this); } override void releaseHandle () { super.releaseHandle (); handle = null; parent = null; } override void releaseParent () { parent.removeControl (this); } override void releaseWidget () { super.releaseWidget (); if (OS.IsDBLocale) { OS.ImmAssociateContext (handle, null); } if (toolTipText_ !is null) { setToolTipText (getShell (), null); } toolTipText_ = null; if (menu !is null && !menu.isDisposed ()) { menu.dispose (); } backgroundImage = null; menu = null; cursor = null; unsubclass (); deregister (); layoutData = null; if (accessible !is null) { accessible.internal_dispose_Accessible (); } accessible = null; region = null; font = 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 <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see ControlListener * @see #addControlListener */ public void removeControlListener (ControlListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.Move, listener); eventTable.unhook (DWT.Resize, listener); } /** * Removes the listener from the collection of listeners who will * be notified when a drag gesture occurs. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see DragDetectListener * @see #addDragDetectListener * * @since 3.3 */ public void removeDragDetectListener(DragDetectListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.DragDetect, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the control gains or loses focus. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see FocusListener * @see #addFocusListener */ public void removeFocusListener(FocusListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.FocusIn, listener); eventTable.unhook (DWT.FocusOut, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the help events are generated for the control. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see HelpListener * @see #addHelpListener */ public void removeHelpListener (HelpListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.Help, 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 <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see KeyListener * @see #addKeyListener */ public void removeKeyListener(KeyListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.KeyUp, listener); eventTable.unhook (DWT.KeyDown, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the platform-specific context menu trigger has * occurred. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MenuDetectListener * @see #addMenuDetectListener * * @since 3.3 */ public void removeMenuDetectListener (MenuDetectListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.MenuDetect, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the mouse passes or hovers over controls. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseTrackListener * @see #addMouseTrackListener */ public void removeMouseTrackListener(MouseTrackListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.MouseEnter, listener); eventTable.unhook (DWT.MouseExit, listener); eventTable.unhook (DWT.MouseHover, listener); } /** * Removes the listener from the collection of listeners who will * be notified when mouse buttons are pressed and released. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseListener * @see #addMouseListener */ public void removeMouseListener (MouseListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.MouseDown, listener); eventTable.unhook (DWT.MouseUp, listener); eventTable.unhook (DWT.MouseDoubleClick, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the mouse moves. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseMoveListener * @see #addMouseMoveListener */ public void removeMouseMoveListener(MouseMoveListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.MouseMove, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the mouse wheel is scrolled. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see MouseWheelListener * @see #addMouseWheelListener * * @since 3.3 */ public void removeMouseWheelListener (MouseWheelListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.MouseWheel, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the receiver needs to be painted. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see PaintListener * @see #addPaintListener */ public void removePaintListener(PaintListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook(DWT.Paint, listener); } /** * Removes the listener from the collection of listeners who will * be notified when traversal events occur. * * @param listener the listener which should no longer be notified * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see TraverseListener * @see #addTraverseListener */ public void removeTraverseListener(TraverseListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.Traverse, listener); } void showWidget (bool visible) { auto topHandle_ = topHandle (); OS.ShowWindow (topHandle_, visible ? OS.SW_SHOW : OS.SW_HIDE); if (handle !is topHandle_) OS.ShowWindow (handle, visible ? OS.SW_SHOW : OS.SW_HIDE); } override bool sendFocusEvent (int type) { Shell shell = getShell (); /* * Feature in Windows. During the processing of WM_KILLFOCUS, * when the focus window is queried using GetFocus(), it has * already been assigned to the new window. The fix is to * remember the control that is losing or gaining focus and * answer it during WM_KILLFOCUS. If a WM_SETFOCUS occurs * during WM_KILLFOCUS, the focus control needs to be updated * to the current control. At any other time, the focus * control matches Windows. */ Display display = this.display; display.focusEvent = type; display.focusControl = this; sendEvent (type); // widget could be disposed at this point display.focusEvent = DWT.None; display.focusControl = null; /* * It is possible that the shell may be * disposed at this point. If this happens * don't send the activate and deactivate * events. */ if (!shell.isDisposed ()) { switch (type) { case DWT.FocusIn: shell.setActiveControl (this); break; case DWT.FocusOut: if (shell !is display.getActiveShell ()) { shell.setActiveControl (null); } break; default: } } return true; } void sendMove () { sendEvent (DWT.Move); } void sendResize () { sendEvent (DWT.Resize); } void setBackground () { Control control = findBackgroundControl (); if (control is null) control = this; if (control.backgroundImage !is null) { Shell shell = getShell (); shell.releaseBrushes (); setBackgroundImage (control.backgroundImage.handle); } else { setBackgroundPixel (control.background is -1 ? control.defaultBackground() : control.background); } } /** * Sets the receiver's background color to the color specified * by the argument, or to the default system color for the control * if the argument is null. * <p> * Note: This operation is a hint and may be overridden by the platform. * For example, on Windows the background of a Button cannot be changed. * </p> * @param color the new color (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setBackground (Color color) { checkWidget (); int pixel = -1; if (color !is null) { if (color.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); pixel = color.handle; } if (pixel is background) return; background = pixel; updateBackgroundColor (); } /** * Sets the receiver's background image to the image specified * by the argument, or to the default system color for the control * if the argument is null. The background image is tiled to fill * the available space. * <p> * Note: This operation is a hint and may be overridden by the platform. * For example, on Windows the background of a Button cannot be changed. * </p> * @param image the new image (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * <li>ERROR_INVALID_ARGUMENT - if the argument is not a bitmap</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.2 */ public void setBackgroundImage (Image image) { checkWidget (); if (image !is null) { if (image.isDisposed ()) error (DWT.ERROR_INVALID_ARGUMENT); if (image.type !is DWT.BITMAP) error (DWT.ERROR_INVALID_ARGUMENT); } if (backgroundImage is image) return; backgroundImage = image; Shell shell = getShell (); shell.releaseBrushes (); updateBackgroundImage (); } void setBackgroundImage (HBITMAP hBitmap) { static if (OS.IsWinCE) { OS.InvalidateRect (handle, null, true); } else { int flags = OS.RDW_ERASE | OS.RDW_FRAME | OS.RDW_INVALIDATE; OS.RedrawWindow (handle, null, null, flags); } } void setBackgroundPixel (int pixel) { static if (OS.IsWinCE) { OS.InvalidateRect (handle, null, true); } else { int flags = OS.RDW_ERASE | OS.RDW_FRAME | OS.RDW_INVALIDATE; OS.RedrawWindow (handle, null, null, flags); } } /** * Sets the receiver's size and location to the rectangular * area specified by the arguments. The <code>x</code> and * <code>y</code> arguments are relative to the receiver's * parent (or its display if its parent is null), unless * the receiver is a shell. In this case, the <code>x</code> * and <code>y</code> arguments are relative to the display. * <p> * Note: Attempting to set the width or height of the * receiver to a negative number will cause that * value to be set to zero instead. * </p> * * @param x the new x coordinate for the receiver * @param y the new y coordinate for the receiver * @param width the new width for the receiver * @param height the new height for the receiver * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setBounds (int x, int y, int width, int height) { checkWidget (); int flags = OS.SWP_NOZORDER | OS.SWP_DRAWFRAME | OS.SWP_NOACTIVATE; setBounds (x, y, Math.max (0, width), Math.max (0, height), flags); } void setBounds (int x, int y, int width, int height, int flags) { setBounds (x, y, width, height, flags, true); } void setBounds (int x, int y, int width, int height, int flags, bool defer) { if (findImageControl () !is null) { if (backgroundImage is null) flags |= OS.SWP_NOCOPYBITS; } else { if (OS.GetWindow (handle, OS.GW_CHILD) is null) { if (OS.COMCTL32_MAJOR >= 6 && OS.IsAppThemed ()) { if (findThemeControl () !is null) flags |= OS.SWP_NOCOPYBITS; } } } auto topHandle_ = topHandle (); if (defer && parent !is null) { forceResize (); if (parent.lpwp !is null) { int index = 0; auto lpwp = parent.lpwp; while (index < lpwp.length) { if (lpwp [index] is null) break; index ++; } if (index is lpwp.length) { WINDOWPOS* [] newLpwp = new WINDOWPOS* [lpwp.length + 4]; SimpleType!(WINDOWPOS*).arraycopy (lpwp, 0, newLpwp, 0, lpwp.length); parent.lpwp = lpwp = newLpwp; } WINDOWPOS* wp = new WINDOWPOS; wp._hwnd = topHandle_; wp.x = x; wp.y = y; wp.cx = width; wp.cy = height; wp.flags = flags; lpwp [index] = wp; return; } } SetWindowPos (topHandle_, null, x, y, width, height, flags); } /** * Sets the receiver's size and location to the rectangular * area specified by the argument. The <code>x</code> and * <code>y</code> fields of the rectangle are relative to * the receiver's parent (or its display if its parent is null). * <p> * Note: Attempting to set the width or height of the * receiver to a negative number will cause that * value to be set to zero instead. * </p> * * @param rect the new bounds for the receiver * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setBounds (Rectangle rect) { checkWidget (); if (rect is null) error (DWT.ERROR_NULL_ARGUMENT); setBounds (rect.x, rect.y, rect.width, rect.height); } /** * If the argument is <code>true</code>, causes the receiver to have * all mouse events delivered to it until the method is called with * <code>false</code> as the argument. Note that on some platforms, * a mouse button must currently be down for capture to be assigned. * * @param capture <code>true</code> to capture the mouse, and <code>false</code> to release it * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setCapture (bool capture) { checkWidget (); if (capture) { OS.SetCapture (handle); } else { if (OS.GetCapture () is handle) { OS.ReleaseCapture (); } } } void setCursor () { int /*long*/ lParam = OS.MAKELPARAM (OS.HTCLIENT, OS.WM_MOUSEMOVE); OS.SendMessage (handle, OS.WM_SETCURSOR, handle, lParam); } /** * Sets the receiver's cursor to the cursor specified by the * argument, or to the default cursor for that kind of control * if the argument is null. * <p> * When the mouse pointer passes over a control its appearance * is changed to match the control's cursor. * </p> * * @param cursor the new cursor (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setCursor (Cursor cursor) { checkWidget (); if (cursor !is null && cursor.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); this.cursor = cursor; static if (OS.IsWinCE) { int /*long*/ hCursor = cursor !is null ? cursor.handle : 0; OS.SetCursor (hCursor); return; } auto hwndCursor = OS.GetCapture (); if (hwndCursor is null) { POINT pt; if (!OS.GetCursorPos (&pt)) return; auto hwnd = hwndCursor = OS.WindowFromPoint (pt); while (hwnd !is null && hwnd !is handle) { hwnd = OS.GetParent (hwnd); } if (hwnd is null) return; } Control control = display.getControl (hwndCursor); if (control is null) control = this; control.setCursor (); } void setDefaultFont () { auto hFont = display.getSystemFont ().handle; OS.SendMessage (handle, OS.WM_SETFONT, hFont, 0); } /** * Sets the receiver's drag detect state. If the argument is * <code>true</code>, the receiver will detect drag gestures, * otherwise these gestures will be ignored. * * @param dragDetect the new drag detect state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.3 */ public void setDragDetect (bool dragDetect) { checkWidget (); if (dragDetect) { state |= DRAG_DETECT; } else { state &= ~DRAG_DETECT; } enableDrag (dragDetect); } /** * Enables the receiver if the argument is <code>true</code>, * and disables it otherwise. A disabled control is typically * not selectable from the user interface and draws with an * inactive or "grayed" look. * * @param enabled the new enabled state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setEnabled (bool enabled) { checkWidget (); /* * Feature in Windows. If the receiver has focus, disabling * the receiver causes no window to have focus. The fix is * to assign focus to the first ancestor window that takes * focus. If no window will take focus, set focus to the * desktop. */ Control control = null; bool fixFocus_ = false; if (!enabled) { if (display.focusEvent !is DWT.FocusOut) { control = display.getFocusControl (); fixFocus_ = isFocusAncestor (control); } } enableWidget (enabled); if (fixFocus_) fixFocus (control); } bool setFixedFocus () { if ((style & DWT.NO_FOCUS) !is 0) return false; return forceFocus (); } /** * Causes the receiver to have the <em>keyboard focus</em>, * such that all keyboard events will be delivered to it. Focus * reassignment will respect applicable platform constraints. * * @return <code>true</code> if the control got focus, and <code>false</code> if it was unable to. * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #forceFocus */ public bool setFocus () { checkWidget (); if ((style & DWT.NO_FOCUS) !is 0) return false; return forceFocus (); } /** * Sets the font that the receiver will use to paint textual information * to the font specified by the argument, or to the default font for that * kind of control if the argument is null. * * @param font the new font (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setFont (Font font) { checkWidget (); HFONT hFont; if (font !is null) { if (font.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); hFont = font.handle; } this.font = font; if (hFont is null) hFont = defaultFont (); OS.SendMessage (handle, OS.WM_SETFONT, hFont, 1); } /** * Sets the receiver's foreground color to the color specified * by the argument, or to the default system color for the control * if the argument is null. * <p> * Note: This operation is a hint and may be overridden by the platform. * </p> * @param color the new color (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setForeground (Color color) { checkWidget (); int pixel = -1; if (color !is null) { if (color.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); pixel = color.handle; } if (pixel is foreground) return; foreground = pixel; setForegroundPixel (pixel); } void setForegroundPixel (int pixel) { OS.InvalidateRect (handle, null, true); } /** * Sets the layout data associated with the receiver to the argument. * * @param layoutData the new layout data for the receiver. * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setLayoutData (Object layoutData) { checkWidget (); this.layoutData = layoutData; } /** * Sets the receiver's location to the point specified by * the arguments which are relative to the receiver's * parent (or its display if its parent is null), unless * the receiver is a shell. In this case, the point is * relative to the display. * * @param x the new x coordinate for the receiver * @param y the new y coordinate for the receiver * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setLocation (int x, int y) { checkWidget (); int flags = OS.SWP_NOSIZE | OS.SWP_NOZORDER | OS.SWP_NOACTIVATE; /* * Feature in WinCE. The SWP_DRAWFRAME flag for SetWindowPos() * causes a WM_SIZE message to be sent even when the SWP_NOSIZE * flag is specified. The fix is to set SWP_DRAWFRAME only when * not running on WinCE. */ static if (!OS.IsWinCE) flags |= OS.SWP_DRAWFRAME; setBounds (x, y, 0, 0, flags); } /** * Sets the receiver's location to the point specified by * the arguments which are relative to the receiver's * parent (or its display if its parent is null), unless * the receiver is a shell. In this case, the point is * relative to the display. * * @param location the new location for the receiver * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setLocation (Point location) { checkWidget (); if (location is null) error (DWT.ERROR_NULL_ARGUMENT); setLocation (location.x, location.y); } /** * Sets the receiver's pop up menu to the argument. * All controls may optionally have a pop up * menu that is displayed when the user requests one for * the control. The sequence of key strokes, button presses * and/or button releases that are used to request a pop up * menu is platform specific. * <p> * Note: Disposing of a control that has a pop up menu will * dispose of the menu. To avoid this behavior, set the * menu to null before the control is disposed. * </p> * * @param menu the new pop up menu * * @exception IllegalArgumentException <ul> * <li>ERROR_MENU_NOT_POP_UP - the menu is not a pop up menu</li> * <li>ERROR_INVALID_PARENT - if the menu is not in the same widget tree</li> * <li>ERROR_INVALID_ARGUMENT - if the menu has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setMenu (Menu menu) { checkWidget (); if (menu !is null) { if (menu.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); if ((menu.style & DWT.POP_UP) is 0) { error (DWT.ERROR_MENU_NOT_POP_UP); } if (menu.parent !is menuShell ()) { error (DWT.ERROR_INVALID_PARENT); } } this.menu = menu; } bool setRadioFocus () { return false; } bool setRadioSelection (bool value) { return false; } /** * If the argument is <code>false</code>, causes subsequent drawing * operations in the receiver to be ignored. No drawing of any kind * can occur in the receiver until the flag is set to true. * Graphics operations that occurred while the flag was * <code>false</code> are lost. When the flag is set to <code>true</code>, * the entire widget is marked as needing to be redrawn. Nested calls * to this method are stacked. * <p> * Note: This operation is a hint and may not be supported on some * platforms or for some widgets. * </p> * * @param redraw the new redraw state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #redraw(int, int, int, int, bool) * @see #update() */ public void setRedraw (bool redraw) { checkWidget (); /* * Feature in Windows. When WM_SETREDRAW is used to turn * off drawing in a widget, it clears the WS_VISIBLE bits * and then sets them when redraw is turned back on. This * means that WM_SETREDRAW will make a widget unexpectedly * visible. The fix is to track the visibility state while * drawing is turned off and restore it when drawing is * turned back on. */ if (drawCount is 0) { int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); if ((bits & OS.WS_VISIBLE) is 0) state |= HIDDEN; } if (redraw) { if (--drawCount is 0) { auto topHandle_ = topHandle (); OS.SendMessage (topHandle_, OS.WM_SETREDRAW, 1, 0); if (handle !is topHandle_) OS.SendMessage (handle, OS.WM_SETREDRAW, 1, 0); if ((state & HIDDEN) !is 0) { state &= ~HIDDEN; OS.ShowWindow (topHandle_, OS.SW_HIDE); if (handle !is topHandle_) OS.ShowWindow (handle, OS.SW_HIDE); } else { static if (OS.IsWinCE) { OS.InvalidateRect (topHandle_, null, true); if (handle !is topHandle_) OS.InvalidateRect (handle, null, true); } else { int flags = OS.RDW_ERASE | OS.RDW_FRAME | OS.RDW_INVALIDATE | OS.RDW_ALLCHILDREN; OS.RedrawWindow (topHandle_, null, null, flags); } } } } else { if (drawCount++ is 0) { auto topHandle_ = topHandle (); OS.SendMessage (topHandle_, OS.WM_SETREDRAW, 0, 0); if (handle !is topHandle_) OS.SendMessage (handle, OS.WM_SETREDRAW, 0, 0); } } } /** * Sets the shape of the control to the region specified * by the argument. When the argument is null, the * default shape of the control is restored. * * @param region the region that defines the shape of the control (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the region has been disposed</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 3.4 */ public void setRegion (Region region) { checkWidget (); if (region !is null && region.isDisposed()) error (DWT.ERROR_INVALID_ARGUMENT); HRGN hRegion; if (region !is null) { hRegion = OS.CreateRectRgn (0, 0, 0, 0); OS.CombineRgn (hRegion, region.handle, hRegion, OS.RGN_OR); } OS.SetWindowRgn (handle, hRegion, true); this.region = region; } bool setSavedFocus () { return forceFocus (); } /** * Sets the receiver's size to the point specified by the arguments. * <p> * Note: Attempting to set the width or height of the * receiver to a negative number will cause that * value to be set to zero instead. * </p> * * @param width the new width for the receiver * @param height the new height for the receiver * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setSize (int width, int height) { checkWidget (); int flags = OS.SWP_NOMOVE | OS.SWP_NOZORDER | OS.SWP_DRAWFRAME | OS.SWP_NOACTIVATE; setBounds (0, 0, Math.max (0, width), Math.max (0, height), flags); } /** * Sets the receiver's size to the point specified by the argument. * <p> * Note: Attempting to set the width or height of the * receiver to a negative number will cause them to be * set to zero instead. * </p> * * @param size the new size for the receiver * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the point is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setSize (Point size) { checkWidget (); if (size is null) error (DWT.ERROR_NULL_ARGUMENT); setSize (size.x, size.y); } bool setTabGroupFocus () { return setTabItemFocus (); } bool setTabItemFocus () { if (!isShowing ()) return false; return forceFocus (); } /** * Sets the receiver's tool tip text to the argument, which * may be null indicating that no tool tip text should be shown. * * @param string the new tool tip text (or null) * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setToolTipText (String string) { checkWidget (); toolTipText_ = string; setToolTipText (getShell (), string); } void setToolTipText (Shell shell, String string) { shell.setToolTipText (handle, string); } /** * Marks the receiver as visible if the argument is <code>true</code>, * and marks it invisible otherwise. * <p> * If one of the receiver's ancestors is not visible or some * other condition makes the receiver not visible, marking * it visible may not actually cause it to be displayed. * </p> * * @param visible the new visibility state * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public void setVisible (bool visible) { checkWidget (); if (drawCount !is 0) { if (((state & HIDDEN) is 0) is visible) return; } else { int bits = OS.GetWindowLong (handle, OS.GWL_STYLE); if (((bits & OS.WS_VISIBLE) !is 0) is visible) return; } if (visible) { sendEvent (DWT.Show); if (isDisposed ()) return; } /* * Feature in Windows. If the receiver has focus, hiding * the receiver causes no window to have focus. The fix is * to assign focus to the first ancestor window that takes * focus. If no window will take focus, set focus to the * desktop. */ Control control = null; bool fixFocus_ = false; if (!visible) { if (display.focusEvent !is DWT.FocusOut) { control = display.getFocusControl (); fixFocus_ = isFocusAncestor (control); } } if (drawCount !is 0) { state = visible ? state & ~HIDDEN : state | HIDDEN; } else { showWidget (visible); if (isDisposed ()) return; } if (!visible) { sendEvent (DWT.Hide); if (isDisposed ()) return; } if (fixFocus_) fixFocus (control); } void sort (int [] items) { /* Shell Sort from K&R, pg 108 */ int length = items.length; for (int gap=length/2; gap>0; gap/=2) { for (int i=gap; i<length; i++) { for (int j=i-gap; j>=0; j-=gap) { if (items [j] <= items [j + gap]) { int swap = items [j]; items [j] = items [j + gap]; items [j + gap] = swap; } } } } } void subclass () { int /*long*/ oldProc = windowProc (); int newProc = display.windowProc(); if (oldProc is newProc) return; OS.SetWindowLongPtr (handle, OS.GWLP_WNDPROC, newProc); } /** * Returns a point which is the result of converting the * argument, which is specified in display relative coordinates, * to coordinates relative to the receiver. * <p> * @param x the x coordinate to be translated * @param y the y coordinate to be translated * @return the translated coordinates * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 2.1 */ public Point toControl (int x, int y) { checkWidget (); POINT pt; pt.x = x; pt.y = y; OS.ScreenToClient (handle, &pt); return new Point (pt.x, pt.y); } /** * Returns a point which is the result of converting the * argument, which is specified in display relative coordinates, * to coordinates relative to the receiver. * <p> * @param point the point to be translated (must not be null) * @return the translated coordinates * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the point is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Point toControl (Point point) { checkWidget (); if (point is null) error (DWT.ERROR_NULL_ARGUMENT); return toControl (point.x, point.y); } /** * Returns a point which is the result of converting the * argument, which is specified in coordinates relative to * the receiver, to display relative coordinates. * <p> * @param x the x coordinate to be translated * @param y the y coordinate to be translated * @return the translated coordinates * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @since 2.1 */ public Point toDisplay (int x, int y) { checkWidget (); POINT pt; pt.x = x; pt.y = y; OS.ClientToScreen (handle, &pt); return new Point (pt.x, pt.y); } /** * Returns a point which is the result of converting the * argument, which is specified in coordinates relative to * the receiver, to display relative coordinates. * <p> * @param point the point to be translated (must not be null) * @return the translated coordinates * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the point is null</li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public Point toDisplay (Point point) { checkWidget (); if (point is null) error (DWT.ERROR_NULL_ARGUMENT); return toDisplay (point.x, point.y); } HANDLE topHandle () { return handle; } bool translateAccelerator (MSG* msg) { return menuShell ().translateAccelerator (msg); } bool translateMnemonic (Event event, Control control) { if (control is this) return false; if (!isVisible () || !isEnabled ()) return false; event.doit = mnemonicMatch (event.character); return traverse (event); } bool translateMnemonic (MSG* msg) { if (msg.wParam < 0x20) return false; auto hwnd = msg.hwnd; if (OS.GetKeyState (OS.VK_MENU) >= 0) { int /*long*/ code = OS.SendMessage (hwnd, OS.WM_GETDLGCODE, 0, 0); if ((code & OS.DLGC_WANTALLKEYS) !is 0) return false; if ((code & OS.DLGC_BUTTON) is 0) return false; } Decorations shell = menuShell (); if (shell.isVisible () && shell.isEnabled ()) { display.lastAscii = msg.wParam; display.lastNull = display.lastDead = false; Event event = new Event (); event.detail = DWT.TRAVERSE_MNEMONIC; if (setKeyState (event, DWT.Traverse, msg.wParam, msg.lParam)) { return translateMnemonic (event, null) || shell.translateMnemonic (event, this); } } return false; } bool translateTraversal (MSG* msg) { auto hwnd = msg.hwnd; int key = msg.wParam; if (key is OS.VK_MENU) { OS.SendMessage (hwnd, OS.WM_CHANGEUISTATE, OS.UIS_INITIALIZE, 0); return false; } int detail = DWT.TRAVERSE_NONE; bool doit = true, all = false; bool lastVirtual = false; int lastKey = key, lastAscii = 0; switch (key) { case OS.VK_ESCAPE: { all = true; lastAscii = 27; int /*long*/ code = OS.SendMessage (hwnd, OS.WM_GETDLGCODE, 0, 0); if ((code & OS.DLGC_WANTALLKEYS) !is 0) { /* * Use DLGC_HASSETSEL to determine that the control * is a text widget. A text widget normally wants * all keys except VK_ESCAPE. If this bit is not * set, then assume the control wants all keys, * including VK_ESCAPE. */ if ((code & OS.DLGC_HASSETSEL) is 0) doit = false; } detail = DWT.TRAVERSE_ESCAPE; break; } case OS.VK_RETURN: { all = true; lastAscii = '\r'; int /*long*/ code = OS.SendMessage (hwnd, OS.WM_GETDLGCODE, 0, 0); if ((code & OS.DLGC_WANTALLKEYS) !is 0) doit = false; detail = DWT.TRAVERSE_RETURN; break; } case OS.VK_TAB: { lastAscii = '\t'; bool next = OS.GetKeyState (OS.VK_SHIFT) >= 0; int /*long*/ code = OS.SendMessage (hwnd, OS.WM_GETDLGCODE, 0, 0); if ((code & (OS.DLGC_WANTTAB | OS.DLGC_WANTALLKEYS)) !is 0) { /* * Use DLGC_HASSETSEL to determine that the control is a * text widget. If the control is a text widget, then * Ctrl+Tab and Shift+Tab should traverse out of the widget. * If the control is not a text widget, the correct behavior * is to give every character, including Tab, Ctrl+Tab and * Shift+Tab to the control. */ if ((code & OS.DLGC_HASSETSEL) !is 0) { if (next && OS.GetKeyState (OS.VK_CONTROL) >= 0) { doit = false; } } else { doit = false; } } detail = next ? DWT.TRAVERSE_TAB_NEXT : DWT.TRAVERSE_TAB_PREVIOUS; break; } case OS.VK_UP: case OS.VK_LEFT: case OS.VK_DOWN: case OS.VK_RIGHT: { /* * On WinCE SP there is no tab key. Focus is assigned * using the VK_UP and VK_DOWN keys, not with VK_LEFT * or VK_RIGHT. */ if (OS.IsSP) { if (key is OS.VK_LEFT || key is OS.VK_RIGHT) return false; } lastVirtual = true; int /*long*/ code = OS.SendMessage (hwnd, OS.WM_GETDLGCODE, 0, 0); if ((code & (OS.DLGC_WANTARROWS /*| OS.DLGC_WANTALLKEYS*/)) !is 0) doit = false; bool next = key is OS.VK_DOWN || key is OS.VK_RIGHT; if (parent !is null && (parent.style & DWT.MIRRORED) !is 0) { if (key is OS.VK_LEFT || key is OS.VK_RIGHT) next = !next; } detail = next ? DWT.TRAVERSE_ARROW_NEXT : DWT.TRAVERSE_ARROW_PREVIOUS; break; } case OS.VK_PRIOR: case OS.VK_NEXT: { all = true; lastVirtual = true; if (OS.GetKeyState (OS.VK_CONTROL) >= 0) return false; int /*long*/ code = OS.SendMessage (hwnd, OS.WM_GETDLGCODE, 0, 0); if ((code & OS.DLGC_WANTALLKEYS) !is 0) { /* * Use DLGC_HASSETSEL to determine that the control is a * text widget. If the control is a text widget, then * Ctrl+PgUp and Ctrl+PgDn should traverse out of the widget. */ if ((code & OS.DLGC_HASSETSEL) is 0) doit = false; } detail = key is OS.VK_PRIOR ? DWT.TRAVERSE_PAGE_PREVIOUS : DWT.TRAVERSE_PAGE_NEXT; break; } default: return false; } Event event = new Event (); event.doit = doit; event.detail = detail; display.lastKey = lastKey; display.lastAscii = lastAscii; display.lastVirtual = lastVirtual; display.lastNull = display.lastDead = false; if (!setKeyState (event, DWT.Traverse, msg.wParam, msg.lParam)) return false; Shell shell = getShell (); Control control = this; do { if (control.traverse (event)) { OS.SendMessage (hwnd, OS.WM_CHANGEUISTATE, OS.UIS_INITIALIZE, 0); return true; } if (!event.doit && control.hooks (DWT.Traverse)) return false; if (control is shell) return false; control = control.parent; } while (all && control !is null); return false; } bool traverse (Event event) { /* * It is possible (but unlikely), that application * code could have disposed the widget in the traverse * event. If this happens, return true to stop further * event processing. */ sendEvent (DWT.Traverse, event); if (isDisposed ()) return true; if (!event.doit) return false; switch (event.detail) { case DWT.TRAVERSE_NONE: return true; case DWT.TRAVERSE_ESCAPE: return traverseEscape (); case DWT.TRAVERSE_RETURN: return traverseReturn (); case DWT.TRAVERSE_TAB_NEXT: return traverseGroup (true); case DWT.TRAVERSE_TAB_PREVIOUS: return traverseGroup (false); case DWT.TRAVERSE_ARROW_NEXT: return traverseItem (true); case DWT.TRAVERSE_ARROW_PREVIOUS: return traverseItem (false); case DWT.TRAVERSE_MNEMONIC: return traverseMnemonic (event.character); case DWT.TRAVERSE_PAGE_NEXT: return traversePage (true); case DWT.TRAVERSE_PAGE_PREVIOUS: return traversePage (false); default: } return false; } /** * Based on the argument, perform one of the expected platform * traversal action. The argument should be one of the constants: * <code>DWT.TRAVERSE_ESCAPE</code>, <code>DWT.TRAVERSE_RETURN</code>, * <code>DWT.TRAVERSE_TAB_NEXT</code>, <code>DWT.TRAVERSE_TAB_PREVIOUS</code>, * <code>DWT.TRAVERSE_ARROW_NEXT</code> and <code>DWT.TRAVERSE_ARROW_PREVIOUS</code>. * * @param traversal the type of traversal * @return true if the traversal succeeded * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public bool traverse (int traversal) { checkWidget (); Event event = new Event (); event.doit = true; event.detail = traversal; return traverse (event); } bool traverseEscape () { return false; } bool traverseGroup (bool next) { Control root = computeTabRoot (); Control group = computeTabGroup (); Control [] list = root.computeTabList (); int length = list.length; int index = 0; while (index < length) { if (list [index] is group) break; index++; } /* * It is possible (but unlikely), that application * code could have disposed the widget in focus in * or out events. Ensure that a disposed widget is * not accessed. */ if (index is length) return false; int start = index, offset = (next) ? 1 : -1; while ((index = ((index + offset + length) % length)) !is start) { Control control = list [index]; if (!control.isDisposed () && control.setTabGroupFocus ()) { return true; } } if (group.isDisposed ()) return false; return group.setTabGroupFocus (); } bool traverseItem (bool next) { Control [] children = parent._getChildren (); int length = children.length; int index = 0; while (index < length) { if (children [index] is this) break; index++; } /* * It is possible (but unlikely), that application * code could have disposed the widget in focus in * or out events. Ensure that a disposed widget is * not accessed. */ if (index is length) return false; int start = index, offset = (next) ? 1 : -1; while ((index = (index + offset + length) % length) !is start) { Control child = children [index]; if (!child.isDisposed () && child.isTabItem ()) { if (child.setTabItemFocus ()) return true; } } return false; } bool traverseMnemonic (char key) { if (mnemonicHit (key)) { OS.SendMessage (handle, OS.WM_CHANGEUISTATE, OS.UIS_INITIALIZE, 0); return true; } return false; } bool traversePage (bool next) { return false; } bool traverseReturn () { return false; } void unsubclass () { int /*long*/ newProc = windowProc (); int /*long*/ oldProc = display.windowProc; if (oldProc is newProc) return; OS.SetWindowLongPtr (handle, OS.GWLP_WNDPROC, newProc); } /** * Forces all outstanding paint requests for the widget * to be processed before this method returns. If there * are no outstanding paint request, this method does * nothing. * <p> * Note: This method does not cause a redraw. * </p> * * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> * * @see #redraw() * @see #redraw(int, int, int, int, bool) * @see PaintListener * @see DWT#Paint */ public void update () { checkWidget (); update (false); } void update (bool all) { // checkWidget (); static if (OS.IsWinCE) { OS.UpdateWindow (handle); } else { int flags = OS.RDW_UPDATENOW; if (all) flags |= OS.RDW_ALLCHILDREN; OS.RedrawWindow (handle, null, null, flags); } } void updateBackgroundColor () { Control control = findBackgroundControl (); if (control is null) control = this; setBackgroundPixel (control.background); } void updateBackgroundImage () { Control control = findBackgroundControl (); Image image = control !is null ? control.backgroundImage : backgroundImage; setBackgroundImage (image !is null ? image.handle : null); } void updateBackgroundMode () { int oldState = state & PARENT_BACKGROUND; checkBackground (); if (oldState !is (state & PARENT_BACKGROUND)) { setBackground (); } } void updateFont (Font oldFont, Font newFont) { if (getFont () ==/*eq*/oldFont ) setFont (newFont); } void updateImages () { /* Do nothing */ } void updateLayout (bool resize, bool all) { /* Do nothing */ } CREATESTRUCT* widgetCreateStruct () { return null; } int widgetExtStyle () { int bits = 0; if (!OS.IsPPC) { if ((style & DWT.BORDER) !is 0) bits |= OS.WS_EX_CLIENTEDGE; } // if ((style & DWT.BORDER) !is 0) { // if ((style & DWT.FLAT) is 0) bits |= OS.WS_EX_CLIENTEDGE; // } /* * Feature in Windows NT. When CreateWindowEx() is called with * WS_EX_LAYOUTRTL or WS_EX_NOINHERITLAYOUT, CreateWindowEx() * fails to create the HWND. The fix is to not use these bits. */ if (OS.WIN32_VERSION < OS.VERSION (4, 10)) { return bits; } bits |= OS.WS_EX_NOINHERITLAYOUT; if ((style & DWT.RIGHT_TO_LEFT) !is 0) bits |= OS.WS_EX_LAYOUTRTL; return bits; } HWND widgetParent () { return parent.handle; } int widgetStyle () { /* Force clipping of siblings by setting WS_CLIPSIBLINGS */ int bits = OS.WS_CHILD | OS.WS_VISIBLE | OS.WS_CLIPSIBLINGS; // if ((style & DWT.BORDER) !is 0) { // if ((style & DWT.FLAT) !is 0) bits |= OS.WS_BORDER; // } if (OS.IsPPC) { if ((style & DWT.BORDER) !is 0) bits |= OS.WS_BORDER; } return bits; /* * This code is intentionally commented. When clipping * of both siblings and children is not enforced, it is * possible for application code to draw outside of the * control. */ // int bits = OS.WS_CHILD | OS.WS_VISIBLE; // if ((style & DWT.CLIP_SIBLINGS) !is 0) bits |= OS.WS_CLIPSIBLINGS; // if ((style & DWT.CLIP_CHILDREN) !is 0) bits |= OS.WS_CLIPCHILDREN; // return bits; } /** * Changes the parent of the widget to be the one provided if * the underlying operating system supports this feature. * Returns <code>true</code> if the parent is successfully changed. * * @param parent the new parent for the control. * @return <code>true</code> if the parent is changed and <code>false</code> otherwise. * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * <li>ERROR_NULL_ARGUMENT - if the parent is <code>null</code></li> * </ul> * @exception DWTException <ul> * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> * </ul> */ public bool setParent (Composite parent) { checkWidget (); if (parent is null) error (DWT.ERROR_NULL_ARGUMENT); if (parent.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); if (this.parent is parent) return true; if (!isReparentable ()) return false; releaseParent (); Shell newShell = parent.getShell (), oldShell = getShell (); Decorations newDecorations = parent.menuShell (), oldDecorations = menuShell (); if (oldShell !is newShell || oldDecorations !is newDecorations) { Menu [] menus = oldShell.findMenus (this); fixChildren (newShell, oldShell, newDecorations, oldDecorations, menus); } auto topHandle_ = topHandle (); if (OS.SetParent (topHandle_, parent.handle) is null) return false; this.parent = parent; int flags = OS.SWP_NOSIZE | OS.SWP_NOMOVE | OS.SWP_NOACTIVATE; SetWindowPos (topHandle_, cast(HWND)OS.HWND_BOTTOM, 0, 0, 0, 0, flags); return true; } abstract String windowClass (); abstract int /*long*/ windowProc (); int windowProc (HWND hwnd, int msg, int wParam, int lParam) { LRESULT result = null; switch (msg) { case OS.WM_ACTIVATE: result = WM_ACTIVATE (wParam, lParam); break; case OS.WM_CAPTURECHANGED: result = WM_CAPTURECHANGED (wParam, lParam); break; case OS.WM_CHANGEUISTATE: result = WM_CHANGEUISTATE (wParam, lParam); break; case OS.WM_CHAR: result = WM_CHAR (wParam, lParam); break; case OS.WM_CLEAR: result = WM_CLEAR (wParam, lParam); break; case OS.WM_CLOSE: result = WM_CLOSE (wParam, lParam); break; case OS.WM_COMMAND: result = WM_COMMAND (wParam, lParam); break; case OS.WM_CONTEXTMENU: result = WM_CONTEXTMENU (wParam, lParam); break; case OS.WM_CTLCOLORBTN: case OS.WM_CTLCOLORDLG: case OS.WM_CTLCOLOREDIT: case OS.WM_CTLCOLORLISTBOX: case OS.WM_CTLCOLORMSGBOX: case OS.WM_CTLCOLORSCROLLBAR: case OS.WM_CTLCOLORSTATIC: result = WM_CTLCOLOR (wParam, lParam); break; case OS.WM_CUT: result = WM_CUT (wParam, lParam); break; case OS.WM_DESTROY: result = WM_DESTROY (wParam, lParam); break; case OS.WM_DRAWITEM: result = WM_DRAWITEM (wParam, lParam); break; case OS.WM_ENDSESSION: result = WM_ENDSESSION (wParam, lParam); break; case OS.WM_ENTERIDLE: result = WM_ENTERIDLE (wParam, lParam); break; case OS.WM_ERASEBKGND: result = WM_ERASEBKGND (wParam, lParam); break; case OS.WM_GETDLGCODE: result = WM_GETDLGCODE (wParam, lParam); break; case OS.WM_GETFONT: result = WM_GETFONT (wParam, lParam); break; case OS.WM_GETOBJECT: result = WM_GETOBJECT (wParam, lParam); break; case OS.WM_GETMINMAXINFO: result = WM_GETMINMAXINFO (wParam, lParam); break; case OS.WM_HELP: result = WM_HELP (wParam, lParam); break; case OS.WM_HSCROLL: result = WM_HSCROLL (wParam, lParam); break; case OS.WM_IME_CHAR: result = WM_IME_CHAR (wParam, lParam); break; case OS.WM_IME_COMPOSITION: result = WM_IME_COMPOSITION (wParam, lParam); break; case OS.WM_IME_COMPOSITION_START: result = WM_IME_COMPOSITION_START (wParam, lParam); break; case OS.WM_IME_ENDCOMPOSITION: result = WM_IME_ENDCOMPOSITION (wParam, lParam); break; case OS.WM_INITMENUPOPUP: result = WM_INITMENUPOPUP (wParam, lParam); break; case OS.WM_INPUTLANGCHANGE: result = WM_INPUTLANGCHANGE (wParam, lParam); break; case OS.WM_HOTKEY: result = WM_HOTKEY (wParam, lParam); break; case OS.WM_KEYDOWN: result = WM_KEYDOWN (wParam, lParam); break; case OS.WM_KEYUP: result = WM_KEYUP (wParam, lParam); break; case OS.WM_KILLFOCUS: result = WM_KILLFOCUS (wParam, lParam); break; case OS.WM_LBUTTONDBLCLK: result = WM_LBUTTONDBLCLK (wParam, lParam); break; case OS.WM_LBUTTONDOWN: result = WM_LBUTTONDOWN (wParam, lParam); break; case OS.WM_LBUTTONUP: result = WM_LBUTTONUP (wParam, lParam); break; case OS.WM_MBUTTONDBLCLK: result = WM_MBUTTONDBLCLK (wParam, lParam); break; case OS.WM_MBUTTONDOWN: result = WM_MBUTTONDOWN (wParam, lParam); break; case OS.WM_MBUTTONUP: result = WM_MBUTTONUP (wParam, lParam); break; case OS.WM_MEASUREITEM: result = WM_MEASUREITEM (wParam, lParam); break; case OS.WM_MENUCHAR: result = WM_MENUCHAR (wParam, lParam); break; case OS.WM_MENUSELECT: result = WM_MENUSELECT (wParam, lParam); break; case OS.WM_MOUSEACTIVATE: result = WM_MOUSEACTIVATE (wParam, lParam); break; case OS.WM_MOUSEHOVER: result = WM_MOUSEHOVER (wParam, lParam); break; case OS.WM_MOUSELEAVE: result = WM_MOUSELEAVE (wParam, lParam); break; case OS.WM_MOUSEMOVE: result = WM_MOUSEMOVE (wParam, lParam); break; case OS.WM_MOUSEWHEEL: result = WM_MOUSEWHEEL (wParam, lParam); break; case OS.WM_MOVE: result = WM_MOVE (wParam, lParam); break; case OS.WM_NCACTIVATE: result = WM_NCACTIVATE (wParam, lParam); break; case OS.WM_NCCALCSIZE: result = WM_NCCALCSIZE (wParam, lParam); break; case OS.WM_NCHITTEST: result = WM_NCHITTEST (wParam, lParam); break; case OS.WM_NCLBUTTONDOWN: result = WM_NCLBUTTONDOWN (wParam, lParam); break; case OS.WM_NCPAINT: result = WM_NCPAINT (wParam, lParam); break; case OS.WM_NOTIFY: result = WM_NOTIFY (wParam, lParam); break; case OS.WM_PAINT: result = WM_PAINT (wParam, lParam); break; case OS.WM_PALETTECHANGED: result = WM_PALETTECHANGED (wParam, lParam); break; case OS.WM_PARENTNOTIFY: result = WM_PARENTNOTIFY (wParam, lParam); break; case OS.WM_PASTE: result = WM_PASTE (wParam, lParam); break; case OS.WM_PRINT: result = WM_PRINT (wParam, lParam); break; case OS.WM_PRINTCLIENT: result = WM_PRINTCLIENT (wParam, lParam); break; case OS.WM_QUERYENDSESSION: result = WM_QUERYENDSESSION (wParam, lParam); break; case OS.WM_QUERYNEWPALETTE: result = WM_QUERYNEWPALETTE (wParam, lParam); break; case OS.WM_QUERYOPEN: result = WM_QUERYOPEN (wParam, lParam); break; case OS.WM_RBUTTONDBLCLK: result = WM_RBUTTONDBLCLK (wParam, lParam); break; case OS.WM_RBUTTONDOWN: result = WM_RBUTTONDOWN (wParam, lParam); break; case OS.WM_RBUTTONUP: result = WM_RBUTTONUP (wParam, lParam); break; case OS.WM_SETCURSOR: result = WM_SETCURSOR (wParam, lParam); break; case OS.WM_SETFOCUS: result = WM_SETFOCUS (wParam, lParam); break; case OS.WM_SETFONT: result = WM_SETFONT (wParam, lParam); break; case OS.WM_SETTINGCHANGE: result = WM_SETTINGCHANGE (wParam, lParam); break; case OS.WM_SETREDRAW: result = WM_SETREDRAW (wParam, lParam); break; case OS.WM_SHOWWINDOW: result = WM_SHOWWINDOW (wParam, lParam); break; case OS.WM_SIZE: result = WM_SIZE (wParam, lParam); break; case OS.WM_SYSCHAR: result = WM_SYSCHAR (wParam, lParam); break; case OS.WM_SYSCOLORCHANGE: result = WM_SYSCOLORCHANGE (wParam, lParam); break; case OS.WM_SYSCOMMAND: result = WM_SYSCOMMAND (wParam, lParam); break; case OS.WM_SYSKEYDOWN: result = WM_SYSKEYDOWN (wParam, lParam); break; case OS.WM_SYSKEYUP: result = WM_SYSKEYUP (wParam, lParam); break; case OS.WM_TIMER: result = WM_TIMER (wParam, lParam); break; case OS.WM_UNDO: result = WM_UNDO (wParam, lParam); break; case OS.WM_UPDATEUISTATE: result = WM_UPDATEUISTATE (wParam, lParam); break; case OS.WM_VSCROLL: result = WM_VSCROLL (wParam, lParam); break; case OS.WM_WINDOWPOSCHANGED: result = WM_WINDOWPOSCHANGED (wParam, lParam); break; case OS.WM_WINDOWPOSCHANGING: result = WM_WINDOWPOSCHANGING (wParam, lParam); break; case OS.WM_XBUTTONDBLCLK: result = WM_XBUTTONDBLCLK (wParam, lParam); break; case OS.WM_XBUTTONDOWN: result = WM_XBUTTONDOWN (wParam, lParam); break; case OS.WM_XBUTTONUP: result = WM_XBUTTONUP (wParam, lParam); break; default: } if (result !is null) return result.value; return callWindowProc (hwnd, msg, wParam, lParam); } LRESULT WM_ACTIVATE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_CAPTURECHANGED (int /*long*/ wParam, int /*long*/ lParam) { return wmCaptureChanged (handle, wParam, lParam); } LRESULT WM_CHANGEUISTATE (int /*long*/ wParam, int /*long*/ lParam) { if ((state & IGNORE_WM_CHANGEUISTATE) !is 0) return LRESULT.ZERO; return null; } LRESULT WM_CHAR (int /*long*/ wParam, int /*long*/ lParam) { return wmChar (handle, wParam, lParam); } LRESULT WM_CLEAR (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_CLOSE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_COMMAND (int /*long*/ wParam, int /*long*/ lParam) { /* * When the WM_COMMAND message is sent from a * menu, the HWND parameter in LPARAM is zero. */ if (lParam is 0) { Decorations shell = menuShell (); if (shell.isEnabled ()) { int id = OS.LOWORD (wParam); MenuItem item = display.getMenuItem (id); if (item !is null && item.isEnabled ()) { return item.wmCommandChild (wParam, lParam); } } return null; } Control control = display.getControl (cast(HANDLE)lParam); if (control is null) return null; return control.wmCommandChild (wParam, lParam); } LRESULT WM_CONTEXTMENU (int /*long*/ wParam, int /*long*/ lParam) { return wmContextMenu (handle, wParam, lParam); } LRESULT WM_CTLCOLOR (int /*long*/ wParam, int /*long*/ lParam) { auto hPalette = display.hPalette; if (hPalette !is null) { OS.SelectPalette ( cast(HPALETTE)wParam, hPalette, false); OS.RealizePalette (cast(HPALETTE)wParam); } Control control = display.getControl (cast(HANDLE)lParam); if (control is null) return null; return control.wmColorChild (wParam, lParam); } LRESULT WM_CUT (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_DESTROY (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_DRAWITEM (int /*long*/ wParam, int /*long*/ lParam) { DRAWITEMSTRUCT* struct_ = cast(DRAWITEMSTRUCT*)lParam; if (struct_.CtlType is OS.ODT_MENU) { MenuItem item = display.getMenuItem (struct_.itemID); if (item is null) return null; return item.wmDrawChild (wParam, lParam); } Control control = display.getControl (struct_.hwndItem); if (control is null) return null; return control.wmDrawChild (wParam, lParam); } LRESULT WM_ENDSESSION (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_ENTERIDLE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_ERASEBKGND (int /*long*/ wParam, int /*long*/ lParam) { if ((state & DRAW_BACKGROUND) !is 0) { if (findImageControl () !is null) return LRESULT.ONE; } if ((state & THEME_BACKGROUND) !is 0) { if (OS.COMCTL32_MAJOR >= 6 && OS.IsAppThemed ()) { if (findThemeControl () !is null) return LRESULT.ONE; } } return null; } LRESULT WM_GETDLGCODE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_GETFONT (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_GETOBJECT (int /*long*/ wParam, int /*long*/ lParam) { if (accessible !is null) { int /*long*/ result = accessible.internal_WM_GETOBJECT (wParam, lParam); if (result !is 0) return new LRESULT (result); } return null; } LRESULT WM_GETMINMAXINFO (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_HOTKEY (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_HELP (int /*long*/ wParam, int /*long*/ lParam) { static if (OS.IsWinCE) return null; HELPINFO* lphi = cast(HELPINFO*)lParam; Decorations shell = menuShell (); if (!shell.isEnabled ()) return null; if (lphi.iContextType is OS.HELPINFO_MENUITEM) { MenuItem item = display.getMenuItem (lphi.iCtrlId); if (item !is null && item.isEnabled ()) { Widget widget = null; if (item.hooks (DWT.Help)) { widget = item; } else { Menu menu = item.parent; if (menu.hooks (DWT.Help)) widget = menu; } if (widget !is null) { auto hwndShell = shell.handle; OS.SendMessage (hwndShell, OS.WM_CANCELMODE, 0, 0); widget.postEvent (DWT.Help); return LRESULT.ONE; } } return null; } if (hooks (DWT.Help)) { postEvent (DWT.Help); return LRESULT.ONE; } return null; } LRESULT WM_HSCROLL (int /*long*/ wParam, int /*long*/ lParam) { Control control = display.getControl (cast(HANDLE)lParam); if (control is null) return null; return control.wmScrollChild (wParam, lParam); } LRESULT WM_IME_CHAR (int /*long*/ wParam, int /*long*/ lParam) { return wmIMEChar (handle, wParam, lParam); } LRESULT WM_IME_COMPOSITION (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_IME_COMPOSITION_START (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_IME_ENDCOMPOSITION (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_INITMENUPOPUP (int /*long*/ wParam, int /*long*/ lParam) { /* Ignore WM_INITMENUPOPUP for an accelerator */ if (display.accelKeyHit) return null; /* * If the high order word of LPARAM is non-zero, * the menu is the system menu and we can ignore * WPARAM. Otherwise, use WPARAM to find the menu. */ Shell shell = getShell (); Menu oldMenu = shell.activeMenu, newMenu = null; if (OS.HIWORD (lParam) is 0) { newMenu = menuShell ().findMenu (cast(HANDLE)wParam); if (newMenu !is null) newMenu.update (); } Menu menu = newMenu; while (menu !is null && menu !is oldMenu) { menu = menu.getParentMenu (); } if (menu is null) { menu = shell.activeMenu; while (menu !is null) { /* * It is possible (but unlikely), that application * code could have disposed the widget in the hide * event. If this happens, stop searching up the * ancestor list because there is no longer a link * to follow. */ menu.sendEvent (DWT.Hide); if (menu.isDisposed ()) break; menu = menu.getParentMenu (); Menu ancestor = newMenu; while (ancestor !is null && ancestor !is menu) { ancestor = ancestor.getParentMenu (); } if (ancestor !is null) break; } } /* * The shell and the new menu may be disposed because of * sending the hide event to the ancestor menus but setting * a field to null in a disposed shell is not harmful. */ if (newMenu !is null && newMenu.isDisposed ()) newMenu = null; shell.activeMenu = newMenu; /* Send the show event */ if (newMenu !is null && newMenu !is oldMenu) { newMenu.sendEvent (DWT.Show); // widget could be disposed at this point } return null; } LRESULT WM_INPUTLANGCHANGE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_KEYDOWN (int /*long*/ wParam, int /*long*/ lParam) { return wmKeyDown (handle, wParam, lParam); } LRESULT WM_KEYUP (int /*long*/ wParam, int /*long*/ lParam) { return wmKeyUp (handle, wParam, lParam); } LRESULT WM_KILLFOCUS (int /*long*/ wParam, int /*long*/ lParam) { return wmKillFocus (handle, wParam, lParam); } LRESULT WM_LBUTTONDBLCLK (int /*long*/ wParam, int /*long*/ lParam) { return wmLButtonDblClk (handle, wParam, lParam); } LRESULT WM_LBUTTONDOWN (int /*long*/ wParam, int /*long*/ lParam) { return wmLButtonDown (handle, wParam, lParam); } LRESULT WM_LBUTTONUP (int /*long*/ wParam, int /*long*/ lParam) { return wmLButtonUp (handle, wParam, lParam); } LRESULT WM_MBUTTONDBLCLK (int /*long*/ wParam, int /*long*/ lParam) { return wmMButtonDblClk (handle, wParam, lParam); } LRESULT WM_MBUTTONDOWN (int /*long*/ wParam, int /*long*/ lParam) { return wmMButtonDown (handle, wParam, lParam); } LRESULT WM_MBUTTONUP (int /*long*/ wParam, int /*long*/ lParam) { return wmMButtonUp (handle, wParam, lParam); } LRESULT WM_MEASUREITEM (int /*long*/ wParam, int /*long*/ lParam) { MEASUREITEMSTRUCT* struct_ = cast(MEASUREITEMSTRUCT*)lParam;; if (struct_.CtlType is OS.ODT_MENU) { MenuItem item = display.getMenuItem (struct_.itemID); if (item is null) return null; return item.wmMeasureChild (wParam, lParam); } auto hwnd = OS.GetDlgItem (handle, struct_.CtlID); Control control = display.getControl (hwnd); if (control is null) return null; return control.wmMeasureChild (wParam, lParam); } LRESULT WM_MENUCHAR (int /*long*/ wParam, int /*long*/ lParam) { /* * Feature in Windows. When the user types Alt+<key> * and <key> does not match a mnemonic in the System * menu or the menu bar, Windows beeps. This beep is * unexpected and unwanted by applications that look * for Alt+<key>. The fix is to detect the case and * stop Windows from beeping by closing the menu. */ int type = OS.HIWORD (wParam); if (type is 0 || type is OS.MF_SYSMENU) { display.mnemonicKeyHit = false; return new LRESULT (OS.MAKELRESULT (0, OS.MNC_CLOSE)); } return null; } LRESULT WM_MENUSELECT (int /*long*/ wParam, int /*long*/ lParam) { int code = OS.HIWORD (wParam); Shell shell = getShell (); if (code is 0xFFFF && lParam is 0) { Menu menu = shell.activeMenu; while (menu !is null) { /* * When the user cancels any menu that is not the * menu bar, assume a mnemonic key was pressed to open * the menu from WM_SYSCHAR. When the menu was invoked * using the mouse, this assumption is wrong but not * harmful. This variable is only used in WM_SYSCHAR * and WM_SYSCHAR is only sent after the user has pressed * a mnemonic. */ display.mnemonicKeyHit = true; /* * It is possible (but unlikely), that application * code could have disposed the widget in the hide * event. If this happens, stop searching up the * parent list because there is no longer a link * to follow. */ menu.sendEvent (DWT.Hide); if (menu.isDisposed ()) break; menu = menu.getParentMenu (); } /* * The shell may be disposed because of sending the hide * event to the last active menu menu but setting a field * to null in a destroyed widget is not harmful. */ shell.activeMenu = null; return null; } if ((code & OS.MF_SYSMENU) !is 0) return null; if ((code & OS.MF_HILITE) !is 0) { MenuItem item = null; Decorations menuShell = menuShell (); if ((code & OS.MF_POPUP) !is 0) { int index = OS.LOWORD (wParam); MENUITEMINFO info; info.cbSize = OS.MENUITEMINFO_sizeof; info.fMask = OS.MIIM_SUBMENU; if (OS.GetMenuItemInfo (cast(HANDLE)lParam, index, true, &info)) { Menu newMenu = menuShell.findMenu (info.hSubMenu); if (newMenu !is null) item = newMenu.cascade; } } else { Menu newMenu = menuShell.findMenu (cast(HANDLE)lParam); if (newMenu !is null) { int id = OS.LOWORD (wParam); item = display.getMenuItem (id); } Menu oldMenu = shell.activeMenu; if (oldMenu !is null) { Menu ancestor = oldMenu; while (ancestor !is null && ancestor !is newMenu) { ancestor = ancestor.getParentMenu (); } if (ancestor is newMenu) { ancestor = oldMenu; while (ancestor !is newMenu) { /* * It is possible (but unlikely), that application * code could have disposed the widget in the hide * event or the item about to be armed. If this * happens, stop searching up the ancestor list * because there is no longer a link to follow. */ ancestor.sendEvent (DWT.Hide); if (ancestor.isDisposed ()) break; ancestor = ancestor.getParentMenu (); if (ancestor is null) break; } /* * The shell and/or the item could be disposed when * processing hide events from above. If this happens, * ensure that the shell is not accessed and that no * arm event is sent to the item. */ if (!shell.isDisposed ()) { if (newMenu !is null && newMenu.isDisposed ()) { newMenu = null; } shell.activeMenu = newMenu; } if (item !is null && item.isDisposed ()) item = null; } } } if (item !is null) item.sendEvent (DWT.Arm); } return null; } LRESULT WM_MOUSEACTIVATE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_MOUSEHOVER (int /*long*/ wParam, int /*long*/ lParam) { return wmMouseHover (handle, wParam, lParam); } LRESULT WM_MOUSELEAVE (int /*long*/ wParam, int /*long*/ lParam) { if (OS.COMCTL32_MAJOR >= 6) getShell ().fixToolTip (); return wmMouseLeave (handle, wParam, lParam); } LRESULT WM_MOUSEMOVE (int /*long*/ wParam, int /*long*/ lParam) { return wmMouseMove (handle, wParam, lParam); } LRESULT WM_MOUSEWHEEL (int /*long*/ wParam, int /*long*/ lParam) { return wmMouseWheel (handle, wParam, lParam); } LRESULT WM_MOVE (int /*long*/ wParam, int /*long*/ lParam) { state |= MOVE_OCCURRED; if (findImageControl () !is null) { if (this !is getShell ()) redrawChildren (); } else { if ((state & THEME_BACKGROUND) !is 0) { if (OS.COMCTL32_MAJOR >= 6 && OS.IsAppThemed ()) { if (OS.IsWindowVisible (handle)) { if (findThemeControl () !is null) redrawChildren (); } } } } if ((state & MOVE_DEFERRED) is 0) sendEvent (DWT.Move); // widget could be disposed at this point return null; } LRESULT WM_NCACTIVATE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_NCCALCSIZE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_NCHITTEST (int /*long*/ wParam, int /*long*/ lParam) { if (!OS.IsWindowEnabled (handle)) return null; if (!isActive ()) return new LRESULT (OS.HTTRANSPARENT); return null; } LRESULT WM_NCLBUTTONDOWN (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_NCPAINT (int /*long*/ wParam, int /*long*/ lParam) { return wmNCPaint (handle, wParam, lParam); } LRESULT WM_NOTIFY (int /*long*/ wParam, int /*long*/ lParam) { NMHDR* hdr = cast(NMHDR*)lParam; return wmNotify (hdr, wParam, lParam); } LRESULT WM_PAINT (int /*long*/ wParam, int /*long*/ lParam) { return wmPaint (handle, wParam, lParam); } LRESULT WM_PALETTECHANGED (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_PARENTNOTIFY (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_PASTE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_PRINT (int /*long*/ wParam, int /*long*/ lParam) { return wmPrint (handle, wParam, lParam); } LRESULT WM_PRINTCLIENT (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_QUERYENDSESSION (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_QUERYNEWPALETTE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_QUERYOPEN (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_RBUTTONDBLCLK (int /*long*/ wParam, int /*long*/ lParam) { return wmRButtonDblClk (handle, wParam, lParam); } LRESULT WM_RBUTTONDOWN (int /*long*/ wParam, int /*long*/ lParam) { return wmRButtonDown (handle, wParam, lParam); } LRESULT WM_RBUTTONUP (int /*long*/ wParam, int /*long*/ lParam) { return wmRButtonUp (handle, wParam, lParam); } LRESULT WM_SETCURSOR (int /*long*/ wParam, int /*long*/ lParam) { int hitTest = cast(short) OS.LOWORD (lParam); if (hitTest is OS.HTCLIENT) { Control control = display.getControl (cast(HANDLE)wParam); if (control is null) return null; Cursor cursor = control.findCursor (); if (cursor !is null) { OS.SetCursor (cursor.handle); return LRESULT.ONE; } } return null; } LRESULT WM_SETFOCUS (int /*long*/ wParam, int /*long*/ lParam) { return wmSetFocus (handle, wParam, lParam); } LRESULT WM_SETTINGCHANGE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_SETFONT (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_SETREDRAW (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_SHOWWINDOW (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_SIZE (int /*long*/ wParam, int /*long*/ lParam) { state |= RESIZE_OCCURRED; if ((state & RESIZE_DEFERRED) is 0) sendEvent (DWT.Resize); // widget could be disposed at this point return null; } LRESULT WM_SYSCHAR (int /*long*/ wParam, int /*long*/ lParam) { return wmSysChar (handle, wParam, lParam); } LRESULT WM_SYSCOLORCHANGE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_SYSCOMMAND (int /*long*/ wParam, int /*long*/ lParam) { /* * Check to see if the command is a system command or * a user menu item that was added to the System menu. * When a user item is added to the System menu, * WM_SYSCOMMAND must always return zero. * * NOTE: This is undocumented. */ if ((wParam & 0xF000) is 0) { Decorations shell = menuShell (); if (shell.isEnabled ()) { MenuItem item = display.getMenuItem (OS.LOWORD (wParam)); if (item !is null) item.wmCommandChild (wParam, lParam); } return LRESULT.ZERO; } /* Process the System Command */ int cmd = wParam & 0xFFF0; switch (cmd) { case OS.SC_CLOSE: auto hwndShell = menuShell ().handle; int bits = OS.GetWindowLong (hwndShell, OS.GWL_STYLE); if ((bits & OS.WS_SYSMENU) is 0) return LRESULT.ZERO; break; case OS.SC_KEYMENU: /* * When lParam is zero, one of F10, Shift+F10, Ctrl+F10 or * Ctrl+Shift+F10 was pressed. If there is no menu bar and * the focus control is interested in keystrokes, give the * key to the focus control. Normally, F10 with no menu bar * moves focus to the System menu but this can be achieved * using Alt+Space. To allow the application to see F10, * avoid running the default window proc. * * NOTE: When F10 is pressed, WM_SYSCOMMAND is sent to the * shell, not the focus control. This is undocumented Windows * behavior. */ if (lParam is 0) { Decorations shell = menuShell (); Menu menu = shell.getMenuBar (); if (menu is null) { Control control = display._getFocusControl (); if (control !is null) { if (control.hooks (DWT.KeyDown) || control.hooks (DWT.KeyUp)) { display.mnemonicKeyHit = false; return LRESULT.ZERO; } } } } else { /* * When lParam is not zero, Alt+<key> was pressed. If the * application is interested in keystrokes and there is a * menu bar, check to see whether the key that was pressed * matches a mnemonic on the menu bar. Normally, Windows * matches the first character of a menu item as well as * matching the mnemonic character. To allow the application * to see the keystrokes in this case, avoid running the default * window proc. * * NOTE: When the user types Alt+Space, the System menu is * activated. In this case the application should not see * the keystroke. */ if (hooks (DWT.KeyDown) || hooks (DWT.KeyUp)) { if (lParam !is ' ') { Decorations shell = menuShell (); Menu menu = shell.getMenuBar (); if (menu !is null) { char key = Display.mbcsToWcs (lParam); if (key !is 0) { key = CharacterToLower (key); MenuItem [] items = menu.getItems (); for (int i=0; i<items.length; i++) { MenuItem item = items [i]; String text = item.getText (); char mnemonic = findMnemonic (text); if (text.length > 0 && mnemonic is 0) { char ch = text.charAt (0); if (CharacterToLower (ch) is key) { display.mnemonicKeyHit = false; return LRESULT.ZERO; } } } } } else { display.mnemonicKeyHit = false; } } } } // FALL THROUGH case OS.SC_HSCROLL: case OS.SC_VSCROLL: /* * Do not allow keyboard traversal of the menu bar * or scrolling when the shell is not enabled. */ Decorations shell = menuShell (); if (!shell.isEnabled () || !shell.isActive ()) { return LRESULT.ZERO; } break; case OS.SC_MINIMIZE: /* Save the focus widget when the shell is minimized */ menuShell ().saveFocus (); break; default: } return null; } LRESULT WM_SYSKEYDOWN (int /*long*/ wParam, int /*long*/ lParam) { return wmSysKeyDown (handle, wParam, lParam); } LRESULT WM_SYSKEYUP (int /*long*/ wParam, int /*long*/ lParam) { return wmSysKeyUp (handle, wParam, lParam); } LRESULT WM_TIMER (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_UNDO (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_UPDATEUISTATE (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT WM_VSCROLL (int /*long*/ wParam, int /*long*/ lParam) { Control control = display.getControl (cast(HANDLE)lParam); if (control is null) return null; return control.wmScrollChild (wParam, lParam); } LRESULT WM_WINDOWPOSCHANGED (int /*long*/ wParam, int /*long*/ lParam) { try { display.resizeCount++; int /*long*/ code = callWindowProc (handle, OS.WM_WINDOWPOSCHANGED, wParam, lParam); return code is 0 ? LRESULT.ZERO : new LRESULT (code); } finally { --display.resizeCount; } } LRESULT WM_WINDOWPOSCHANGING (int /*long*/ wParam, int /*long*/ lParam) { /* * Bug in Windows. When WM_SETREDRAW is used to turn off drawing * for a control and the control is moved or resized, Windows does * not redraw the area where the control once was in the parent. * The fix is to detect this case and redraw the area. */ if (drawCount !is 0) { Shell shell = getShell (); if (shell !is this) { WINDOWPOS* lpwp = cast(WINDOWPOS*)lParam; if ((lpwp.flags & OS.SWP_NOMOVE) is 0 || (lpwp.flags & OS.SWP_NOSIZE) is 0) { RECT rect; OS.GetWindowRect (topHandle (), &rect); int width = rect.right - rect.left; int height = rect.bottom - rect.top; if (width !is 0 && height !is 0) { auto hwndParent = parent is null ? null : parent.handle; OS.MapWindowPoints (null, hwndParent, cast(POINT*)&rect, 2); static if (OS.IsWinCE) { OS.InvalidateRect (hwndParent, &rect, true); } else { auto rgn1 = OS.CreateRectRgn (rect.left, rect.top, rect.right, rect.bottom); auto rgn2 = OS.CreateRectRgn (lpwp.x, lpwp.y, lpwp.x + lpwp.cx, lpwp.y + lpwp.cy); OS.CombineRgn (rgn1, rgn1, rgn2, OS.RGN_DIFF); int flags = OS.RDW_ERASE | OS.RDW_FRAME | OS.RDW_INVALIDATE | OS.RDW_ALLCHILDREN; OS.RedrawWindow (hwndParent, null, rgn1, flags); OS.DeleteObject (rgn1); OS.DeleteObject (rgn2); } } } } } return null; } LRESULT WM_XBUTTONDBLCLK (int /*long*/ wParam, int /*long*/ lParam) { return wmXButtonDblClk (handle, wParam, lParam); } LRESULT WM_XBUTTONDOWN (int /*long*/ wParam, int /*long*/ lParam) { return wmXButtonDown (handle, wParam, lParam); } LRESULT WM_XBUTTONUP (int /*long*/ wParam, int /*long*/ lParam) { return wmXButtonUp (handle, wParam, lParam); } LRESULT wmColorChild (int /*long*/ wParam, int /*long*/ lParam) { Control control = findBackgroundControl (); if (control is null) { if ((state & THEME_BACKGROUND) !is 0) { if (OS.COMCTL32_MAJOR >= 6 && OS.IsAppThemed ()) { control = findThemeControl (); if (control !is null) { RECT rect; OS.GetClientRect (handle, &rect); OS.SetTextColor (cast(HANDLE)wParam, getForegroundPixel ()); OS.SetBkColor (cast(HANDLE)wParam, getBackgroundPixel ()); fillThemeBackground (cast(HANDLE)wParam, control, &rect); OS.SetBkMode (cast(HANDLE)wParam, OS.TRANSPARENT); return new LRESULT ( cast(int) OS.GetStockObject (OS.NULL_BRUSH)); } } } if (foreground is -1) return null; } if (control is null) control = this; int forePixel = getForegroundPixel (); int backPixel = control.getBackgroundPixel (); OS.SetTextColor (cast(HANDLE)wParam, forePixel); OS.SetBkColor (cast(HANDLE)wParam, backPixel); if (control.backgroundImage !is null) { RECT rect; OS.GetClientRect (handle, &rect); auto hwnd = control.handle; auto hBitmap = control.backgroundImage.handle; OS.MapWindowPoints (handle, hwnd, cast(POINT*)&rect, 2); POINT lpPoint; OS.GetWindowOrgEx (cast(HANDLE)wParam, &lpPoint); OS.SetBrushOrgEx (cast(HANDLE)wParam, -rect.left - lpPoint.x, -rect.top - lpPoint.y, &lpPoint); auto hBrush = findBrush (cast(int)hBitmap, OS.BS_PATTERN); if ((state & DRAW_BACKGROUND) !is 0) { auto hOldBrush = OS.SelectObject (cast(HANDLE)wParam, hBrush); OS.MapWindowPoints (hwnd, handle, cast(POINT*)&rect, 2); OS.PatBlt (cast(HANDLE)wParam, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, OS.PATCOPY); OS.SelectObject (cast(HANDLE)wParam, hOldBrush); } OS.SetBkMode (cast(HANDLE)wParam, OS.TRANSPARENT); return new LRESULT ( cast(int) hBrush); } auto hBrush = findBrush (backPixel, OS.BS_SOLID); if ((state & DRAW_BACKGROUND) !is 0) { RECT rect; OS.GetClientRect (handle, &rect); auto hOldBrush = OS.SelectObject (cast(HANDLE)wParam, hBrush); OS.PatBlt (cast(HANDLE)wParam, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, OS.PATCOPY); OS.SelectObject (cast(HANDLE)wParam, hOldBrush); } return new LRESULT ( cast(int) hBrush); } LRESULT wmCommandChild (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT wmDrawChild (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT wmMeasureChild (int /*long*/ wParam, int /*long*/ lParam) { return null; } LRESULT wmNotify (NMHDR* hdr, int wParam, int lParam) { Control control = display.getControl (hdr.hwndFrom); if (control is null) return null; return control.wmNotifyChild (hdr, wParam, lParam); } LRESULT wmNotifyChild (NMHDR* hdr, int wParam, int lParam) { return null; } LRESULT wmScrollChild (int /*long*/ wParam, int /*long*/ lParam) { return null; } }