root/dwt/widgets/Button.d

/*******************************************************************************
 * 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.Button;

import dwt.DWT;
import dwt.DWTException;
import dwt.events.SelectionEvent;
import dwt.events.SelectionListener;
import dwt.graphics.GC;
import dwt.graphics.Image;
import dwt.graphics.ImageData;
import dwt.graphics.Point;
import dwt.graphics.Rectangle;
import dwt.internal.ImageList;
import dwt.internal.win32.OS;

import dwt.widgets.Control;
import dwt.widgets.Composite;
import dwt.widgets.TypedListener;

import dwt.dwthelper.utils;

/**
 * Instances of this class represent a selectable user interface object that
 * issues notification when pressed and released.
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>ARROW, CHECK, PUSH, RADIO, TOGGLE, FLAT</dd>
 * <dd>UP, DOWN, LEFT, RIGHT, CENTER</dd>
 * <dt><b>Events:</b></dt>
 * <dd>Selection</dd>
 * </dl>
 * <p>
 * Note: Only one of the styles ARROW, CHECK, PUSH, RADIO, and TOGGLE
 * may be specified.
 * </p><p>
 * Note: Only one of the styles LEFT, RIGHT, and CENTER may be specified.
 * </p><p>
 * Note: Only one of the styles UP, DOWN, LEFT, and RIGHT may be specified
 * when the ARROW style is 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/#button">Button 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 class Button : Control {

    alias Control.computeSize computeSize;
    alias Control.windowProc windowProc;

    alias extern(Windows) int function( HWND, uint, uint, int ) TWindowProc;
    String text = "", message = "";
    Image image, image2, disabledImage;
    ImageList imageList;
    bool ignoreMouse, grayed;
    static const int MARGIN = 4;
    private static /+const+/ int CHECK_WIDTH, CHECK_HEIGHT;
    static const int ICON_WIDTH = 128, ICON_HEIGHT = 128;
    static const bool COMMAND_LINK = false;
    private static /+const+/ TWindowProc ButtonProc;
    static const TCHAR[] ButtonClass = "BUTTON\0";

    private static bool static_this_completed = false;
    private static void static_this() {
        if( static_this_completed ){
            return;
        }
        synchronized {
            if( static_this_completed ){
                return;
            }
            auto hBitmap = OS.LoadBitmap (null, OS.OBM_CHECKBOXES);
            if (hBitmap is null) {
                CHECK_WIDTH = OS.GetSystemMetrics (OS.IsWinCE ? OS.SM_CXSMICON : OS.SM_CXVSCROLL);
                CHECK_HEIGHT = OS.GetSystemMetrics (OS.IsWinCE ? OS.SM_CYSMICON : OS.SM_CYVSCROLL);
            } else {
                BITMAP bitmap;
                OS.GetObject (hBitmap, BITMAP.sizeof, &bitmap);
                OS.DeleteObject (hBitmap);
                CHECK_WIDTH = bitmap.bmWidth / 4;
                CHECK_HEIGHT =  bitmap.bmHeight / 3;
            }
            WNDCLASS lpWndClass;
            OS.GetClassInfo (null, ButtonClass.ptr, &lpWndClass);
            ButtonProc = lpWndClass.lpfnWndProc;
            static_this_completed = true;
        }
    }

/**
 * 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#ARROW
 * @see DWT#CHECK
 * @see DWT#PUSH
 * @see DWT#RADIO
 * @see DWT#TOGGLE
 * @see DWT#FLAT
 * @see DWT#LEFT
 * @see DWT#RIGHT
 * @see DWT#CENTER
 * @see Widget#checkSubclass
 * @see Widget#getStyle
 */
public this (Composite parent, int style) {
    static_this();
    super (parent, checkStyle (style));
}

void _setImage (Image image) {
    if ((style & DWT.COMMAND) !is 0) return;
    if (OS.COMCTL32_MAJOR >= 6) {
        if (imageList !is null) imageList.dispose ();
        imageList = null;
        if (image !is null) {
            imageList = new ImageList (style & DWT.RIGHT_TO_LEFT);
            if (OS.IsWindowEnabled (handle)) {
                imageList.add (image);
            } else {
                if (disabledImage !is null) disabledImage.dispose ();
                disabledImage = new Image (display, image, DWT.IMAGE_DISABLE);
                imageList.add (disabledImage);
            }
            BUTTON_IMAGELIST buttonImageList;
            buttonImageList.himl = imageList.getHandle ();
            int oldBits = OS.GetWindowLong (handle, OS.GWL_STYLE), newBits = oldBits;
            newBits &= ~(OS.BS_LEFT | OS.BS_CENTER | OS.BS_RIGHT);
            if ((style & DWT.LEFT) !is 0) newBits |= OS.BS_LEFT;
            if ((style & DWT.CENTER) !is 0) newBits |= OS.BS_CENTER;
            if ((style & DWT.RIGHT) !is 0) newBits |= OS.BS_RIGHT;
            if (text.length is 0) {
                if ((style & DWT.LEFT) !is 0) buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_LEFT;
                if ((style & DWT.CENTER) !is 0) buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_CENTER;
                if ((style & DWT.RIGHT) !is 0) buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_RIGHT;
            } else {
                buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_LEFT;
                buttonImageList.margin.left = computeLeftMargin ();
                buttonImageList.margin.right = MARGIN;
                newBits &= ~(OS.BS_CENTER | OS.BS_RIGHT);
                newBits |= OS.BS_LEFT;
            }
            if (newBits !is oldBits) {
                OS.SetWindowLong (handle, OS.GWL_STYLE, newBits);
                OS.InvalidateRect (handle, null, true);
            }
            OS.SendMessage (handle, OS.BCM_SETIMAGELIST, 0, &buttonImageList);
        } else {
            OS.SendMessage (handle, OS.BCM_SETIMAGELIST, 0, 0);
        }
        /*
        * Bug in Windows.  Under certain cirumstances yet to be
        * isolated, BCM_SETIMAGELIST does not redraw the control
        * when a new image is set.  The fix is to force a redraw.
        */
        OS.InvalidateRect (handle, null, true);
    } else {
        if (image2 !is null) image2.dispose ();
        image2 = null;
        HBITMAP hImage;
        int imageBits = 0, fImageType = 0;
        if (image !is null) {
            switch (image.type) {
                case DWT.BITMAP: {
                    Rectangle rect = image.getBounds ();
                    ImageData data = image.getImageData ();
                    switch (data.getTransparencyType ()) {
                        case DWT.TRANSPARENCY_PIXEL:
                            if (rect.width <= ICON_WIDTH && rect.height <= ICON_HEIGHT) {
                                image2 = new Image (display, data, data.getTransparencyMask ());
                                hImage = image2.handle;
                                imageBits = OS.BS_ICON;
                                fImageType = OS.IMAGE_ICON;
                                break;
                            }
                            //FALL THROUGH
                        case DWT.TRANSPARENCY_ALPHA:
                            image2 = new Image (display, rect.width, rect.height);
                            GC gc = new GC (image2);
                            gc.setBackground (getBackground ());
                            gc.fillRectangle (rect);
                            gc.drawImage (image, 0, 0);
                            gc.dispose ();
                            hImage = image2.handle;
                            imageBits = OS.BS_BITMAP;
                            fImageType = OS.IMAGE_BITMAP;
                            break;
                        case DWT.TRANSPARENCY_NONE:
                            hImage = image.handle;
                            imageBits = OS.BS_BITMAP;
                            fImageType = OS.IMAGE_BITMAP;
                            break;
                        default:
                    }
                    break;
                }
                case DWT.ICON: {
                    hImage = image.handle;
                    imageBits = OS.BS_ICON;
                    fImageType = OS.IMAGE_ICON;
                    break;
                }
                default:
            }
            /*
            * Feature in Windows.  The button control mirrors its image when the
            * flag WS_EX_LAYOUTRTL is set. This behaviour is not desirable in DWT.
            * The fix is to set a mirrored version of real image in the button.
            */
            if ((style & DWT.RIGHT_TO_LEFT) !is 0) {
                if (!OS.IsWinCE && OS.WIN32_VERSION >= OS.VERSION (4, 10)) {
                    Rectangle rect = image.getBounds ();
                    auto hDC = OS.GetDC (handle);
                    auto dstHdc = OS.CreateCompatibleDC (hDC);
                    auto hBitmap = OS.CreateCompatibleBitmap (hDC, rect.width, rect.height);
                    auto oldBitmap = OS.SelectObject (dstHdc, hBitmap);
                    OS.SetLayout (dstHdc, OS.LAYOUT_RTL);
                    if (fImageType is OS.IMAGE_BITMAP) {
                        auto srcHdc = OS.CreateCompatibleDC (hDC);
                        auto oldSrcBitmap = OS.SelectObject (srcHdc, hImage);
                        OS.SetLayout (dstHdc, 0);
                        OS.BitBlt (dstHdc, 0, 0, rect.width, rect.height, srcHdc, 0, 0, OS.SRCCOPY);
                        OS.SelectObject (srcHdc, oldSrcBitmap);
                        OS.DeleteDC (srcHdc);
                    } else {
                        Control control = findBackgroundControl ();
                        if (control is null) control = this;
                        auto newBrush = OS.CreateSolidBrush (control.getBackgroundPixel ());
                        auto oldBrush = OS.SelectObject (dstHdc, newBrush);
                        OS.PatBlt (dstHdc, 0, 0, rect.width, rect.height, OS.PATCOPY);
                        OS.DrawIconEx (dstHdc, 0, 0, hImage, 0, 0, 0, null, OS.DI_NORMAL);
                        OS.SelectObject (dstHdc, oldBrush);
                        OS.DeleteObject (newBrush);
                    }
                    OS.SelectObject (dstHdc, oldBitmap);
                    OS.DeleteDC (dstHdc);
                    OS.ReleaseDC (handle, hDC);
                    if (image2 !is null) image2.dispose ();
                    image2 = Image.win32_new (display, DWT.BITMAP, hBitmap);
                    imageBits = OS.BS_BITMAP;
                    fImageType = OS.IMAGE_BITMAP;
                    hImage = hBitmap;
                }
            }
        }
        int newBits = OS.GetWindowLong (handle, OS.GWL_STYLE), oldBits = newBits;
        newBits &= ~(OS.BS_BITMAP | OS.BS_ICON);
        newBits |= imageBits;
        if (newBits !is oldBits) OS.SetWindowLong (handle, OS.GWL_STYLE, newBits);
        OS.SendMessage (handle, OS.BM_SETIMAGE, fImageType, hImage);
    }
}

void _setText (String text) {
    int oldBits = OS.GetWindowLong (handle, OS.GWL_STYLE), newBits = oldBits;
    if (OS.COMCTL32_MAJOR >= 6) {
        newBits &= ~(OS.BS_LEFT | OS.BS_CENTER | OS.BS_RIGHT);
        if ((style & DWT.LEFT) !is 0) newBits |= OS.BS_LEFT;
        if ((style & DWT.CENTER) !is 0) newBits |= OS.BS_CENTER;
        if ((style & DWT.RIGHT) !is 0) newBits |= OS.BS_RIGHT;
        if (imageList !is null) {
            BUTTON_IMAGELIST buttonImageList;
            buttonImageList.himl = imageList.getHandle ();
            if (text.length is 0) {
                if ((style & DWT.LEFT) !is 0) buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_LEFT;
                if ((style & DWT.CENTER) !is 0) buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_CENTER;
                if ((style & DWT.RIGHT) !is 0) buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_RIGHT;
            } else {
                buttonImageList.uAlign = OS.BUTTON_IMAGELIST_ALIGN_LEFT;
                buttonImageList.margin.left = computeLeftMargin ();
                buttonImageList.margin.right = MARGIN;
                newBits &= ~(OS.BS_CENTER | OS.BS_RIGHT);
                newBits |= OS.BS_LEFT;
            }
            OS.SendMessage (handle, OS.BCM_SETIMAGELIST, 0, &buttonImageList);
        }
    } else {
        newBits &= ~(OS.BS_BITMAP | OS.BS_ICON);
    }
    if (newBits !is oldBits) {
        OS.SetWindowLong (handle, OS.GWL_STYLE, newBits);
        OS.InvalidateRect (handle, null, true);
    }
    /*
    * Bug in Windows.  When a Button control is right-to-left and
    * is disabled, the first pixel of the text is clipped.  The
    * fix is to add a space to both sides of the text.
    */
    if ((style & DWT.RIGHT_TO_LEFT) !is 0) {
        if (OS.COMCTL32_MAJOR < 6 || !OS.IsAppThemed ()) {
            text = OS.IsWindowEnabled (handle) ? text : " " ~ text ~ " ";
        }
    }
    TCHAR* buffer = StrToTCHARz ( text );
    OS.SetWindowText (handle, buffer);
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when the control is selected by the user, by sending
 * it one of the messages defined in the <code>SelectionListener</code>
 * interface.
 * <p>
 * <code>widgetSelected</code> is called when the control is selected by the user.
 * <code>widgetDefaultSelected</code> is not called.
 * </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 SelectionListener
 * @see #removeSelectionListener
 * @see SelectionEvent
 */
public void addSelectionListener (SelectionListener listener) {
    checkWidget ();
    if (listener is null) error (DWT.ERROR_NULL_ARGUMENT);
    TypedListener typedListener = new TypedListener (listener);
    addListener (DWT.Selection,typedListener);
    addListener (DWT.DefaultSelection,typedListener);
}

override int callWindowProc (HWND hwnd, int msg, int wParam, int lParam) {
    if (handle is null) return 0;
    return OS.CallWindowProc ( ButtonProc, hwnd, msg, wParam, lParam);
}

static int checkStyle (int style) {
    style = checkBits (style, DWT.PUSH, DWT.ARROW, DWT.CHECK, DWT.RADIO, DWT.TOGGLE, COMMAND_LINK ? DWT.COMMAND : 0);
    if ((style & (DWT.PUSH | DWT.TOGGLE)) !is 0) {
        return checkBits (style, DWT.CENTER, DWT.LEFT, DWT.RIGHT, 0, 0, 0);
    }
    if ((style & (DWT.CHECK | DWT.RADIO)) !is 0) {
        return checkBits (style, DWT.LEFT, DWT.RIGHT, DWT.CENTER, 0, 0, 0);
    }
    if ((style & DWT.ARROW) !is 0) {
        style |= DWT.NO_FOCUS;
        return checkBits (style, DWT.UP, DWT.DOWN, DWT.LEFT, DWT.RIGHT, 0, 0);
    }
    return style;
}

void click () {
    /*
    * Feature in Windows.  BM_CLICK sends a fake WM_LBUTTONDOWN and
    * WM_LBUTTONUP in order to click the button.  This causes the
    * application to get unexpected mouse events.  The fix is to
    * ignore mouse events when they are caused by BM_CLICK.
    */
    ignoreMouse = true;
    OS.SendMessage (handle, OS.BM_CLICK, 0, 0);
    ignoreMouse = false;
}

int computeLeftMargin () {
    if (OS.COMCTL32_MAJOR < 6) return MARGIN;
    if ((style & (DWT.PUSH | DWT.TOGGLE)) is 0) return MARGIN;
    int margin = 0;
    if (image !is null && text.length !is 0) {
        Rectangle bounds = image.getBounds ();
        margin += bounds.width + MARGIN * 2;
        HFONT oldFont;
        auto hDC = OS.GetDC (handle);
        HFONT newFont = cast(HFONT) OS.SendMessage (handle, OS.WM_GETFONT, 0, 0);
        if (newFont !is null) oldFont = OS.SelectObject (hDC, newFont);
        TCHAR* buffer = StrToTCHARz( getCodePage (), text);
        RECT rect;
        int flags = OS.DT_CALCRECT | OS.DT_SINGLELINE;
        OS.DrawText (hDC, buffer, -1, &rect, flags);
        margin += rect.right - rect.left;
        if (newFont !is null) OS.SelectObject (hDC, oldFont);
        OS.ReleaseDC (handle, hDC);
        OS.GetClientRect (handle, &rect);
        margin = Math.max (MARGIN, (rect.right - rect.left - margin) / 2);
    }
    return margin;
}

override public Point computeSize (int wHint, int hHint, bool changed) {
    checkWidget ();
    int width = 0, height = 0, border = getBorderWidth ();
    if ((style & DWT.ARROW) !is 0) {
        if ((style & (DWT.UP | DWT.DOWN)) !is 0) {
            width += OS.GetSystemMetrics (OS.SM_CXVSCROLL);
            height += OS.GetSystemMetrics (OS.SM_CYVSCROLL);
        } else {
            width += OS.GetSystemMetrics (OS.SM_CXHSCROLL);
            height += OS.GetSystemMetrics (OS.SM_CYHSCROLL);
        }
    } else {
        if ((style & DWT.COMMAND) !is 0) {
            SIZE size;
            if (wHint !is DWT.DEFAULT) {
                size.cx = wHint;
                OS.SendMessage (handle, OS.BCM_GETIDEALSIZE, 0, &size);
                width = size.cx;
                height = size.cy;
            } else {
                OS.SendMessage (handle, OS.BCM_GETIDEALSIZE, 0, &size);
                width = size.cy;
                height = size.cy;
                size.cy = 0;
                while (size.cy !is height) {
                    size.cx = width++;
                    size.cy = 0;
                    OS.SendMessage (handle, OS.BCM_GETIDEALSIZE, 0, &size);
                }
            }
        } else {
            int extra = 0;
            bool hasImage = image !is null, hasText = true;
            if (OS.COMCTL32_MAJOR < 6) {
                if ((style & DWT.PUSH) is 0) {
                    int bits = OS.GetWindowLong (handle, OS.GWL_STYLE);
                    hasImage = (bits & (OS.BS_BITMAP | OS.BS_ICON)) !is 0;
                    if (hasImage) hasText = false;
                }
            }
            if (hasImage) {
                if (image !is null) {
                    Rectangle rect = image.getBounds ();
                    width = rect.width;
                    if (hasText && text.length !is 0) {
                        width += MARGIN * 2;
                    }
                    height = rect.height;
                    extra = MARGIN <