root/dwt/widgets/Decorations.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.Decorations;


import dwt.DWT;
import dwt.DWTException;
import dwt.graphics.Image;
import dwt.graphics.ImageData;
import dwt.graphics.Point;
import dwt.graphics.Rectangle;
import dwt.internal.win32.OS;

import dwt.widgets.Canvas;
import dwt.widgets.Menu;
import dwt.widgets.Control;
import dwt.widgets.Button;
import dwt.widgets.Composite;
import dwt.widgets.Event;
import dwt.widgets.Shell;
import dwt.widgets.MenuItem;
import dwt.widgets.Display;

import dwt.dwthelper.utils;

/**
 * Instances of this class provide the appearance and
 * behavior of <code>Shells</code>, but are not top
 * level shells or dialogs. Class <code>Shell</code>
 * shares a significant amount of code with this class,
 * and is a subclass.
 * <p>
 * IMPORTANT: This class was intended to be abstract and
 * should <em>never</em> be referenced or instantiated.
 * Instead, the class <code>Shell</code> should be used.
 * </p>
 * <p>
 * Instances are always displayed in one of the maximized,
 * minimized or normal states:
 * <ul>
 * <li>
 * When an instance is marked as <em>maximized</em>, the
 * window manager will typically resize it to fill the
 * entire visible area of the display, and the instance
 * is usually put in a state where it can not be resized
 * (even if it has style <code>RESIZE</code>) until it is
 * no longer maximized.
 * </li><li>
 * When an instance is in the <em>normal</em> state (neither
 * maximized or minimized), its appearance is controlled by
 * the style constants which were specified when it was created
 * and the restrictions of the window manager (see below).
 * </li><li>
 * When an instance has been marked as <em>minimized</em>,
 * its contents (client area) will usually not be visible,
 * and depending on the window manager, it may be
 * "iconified" (that is, replaced on the desktop by a small
 * simplified representation of itself), relocated to a
 * distinguished area of the screen, or hidden. Combinations
 * of these changes are also possible.
 * </li>
 * </ul>
 * </p>
 * Note: The styles supported by this class must be treated
 * as <em>HINT</em>s, since the window manager for the
 * desktop on which the instance is visible has ultimate
 * control over the appearance and behavior of decorations.
 * For example, some window managers only support resizable
 * windows and will always assume the RESIZE style, even if
 * it is not set.
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>BORDER, CLOSE, MIN, MAX, NO_TRIM, RESIZE, TITLE, ON_TOP, TOOL</dd>
 * <dt><b>Events:</b></dt>
 * <dd>(none)</dd>
 * </dl>
 * Class <code>DWT</code> provides two "convenience constants"
 * for the most commonly required style combinations:
 * <dl>
 * <dt><code>SHELL_TRIM</code></dt>
 * <dd>
 * the result of combining the constants which are required
 * to produce a typical application top level shell: (that
 * is, <code>CLOSE | TITLE | MIN | MAX | RESIZE</code>)
 * </dd>
 * <dt><code>DIALOG_TRIM</code></dt>
 * <dd>
 * the result of combining the constants which are required
 * to produce a typical application dialog shell: (that
 * is, <code>TITLE | CLOSE | BORDER</code>)
 * </dd>
 * </dl>
 * <p>
 * IMPORTANT: This class is intended to be subclassed <em>only</em>
 * within the DWT implementation.
 * </p>
 *
 * @see #getMinimized
 * @see #getMaximized
 * @see Shell
 * @see DWT
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */

public class Decorations : Canvas {

    alias Canvas.setBounds setBounds;
    alias Canvas.setParent setParent;
    alias Canvas.setSavedFocus setSavedFocus;
    alias Canvas.sort sort;
    alias Canvas.windowProc windowProc;

    Image image, smallImage, largeImage;
    Image [] images;
    Menu menuBar;
    Menu [] menus;
    Control savedFocus;
    Button defaultButton, saveDefault;
    int swFlags;
    HACCEL hAccel;
    int nAccel;
    bool moved, resized, opened;
    int oldX = OS.CW_USEDEFAULT, oldY = OS.CW_USEDEFAULT;
    int oldWidth = OS.CW_USEDEFAULT, oldHeight = OS.CW_USEDEFAULT;

/**
 * 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 DWT#CLOSE
 * @see DWT#MIN
 * @see DWT#MAX
 * @see DWT#RESIZE
 * @see DWT#TITLE
 * @see DWT#NO_TRIM
 * @see DWT#SHELL_TRIM
 * @see DWT#DIALOG_TRIM
 * @see DWT#ON_TOP
 * @see DWT#TOOL
 * @see Widget#checkSubclass
 * @see Widget#getStyle
 */
public this (Composite parent, int style) {
    super (parent, checkStyle (style));
}

void _setMaximized (bool maximized) {
    swFlags = maximized ? OS.SW_SHOWMAXIMIZED : OS.SW_RESTORE;
    static if (OS.IsWinCE) {
        /*
        * Note: WinCE does not support SW_SHOWMAXIMIZED and SW_RESTORE. The
        * workaround is to resize the window to fit the parent client area.
        */
        if (maximized) {
            RECT rect;
            OS.SystemParametersInfo (OS.SPI_GETWORKAREA, 0, &rect, 0);
            int width = rect.right - rect.left, height = rect.bottom - rect.top;
            if (OS.IsPPC) {
                /* Leave space for the menu bar */
                if (menuBar !is null) {
                    auto hwndCB = menuBar.hwndCB;
                    RECT rectCB;
                    OS.GetWindowRect (hwndCB, &rectCB);
                    height -= rectCB.bottom - rectCB.top;
                }
            }
            int flags = OS.SWP_NOZORDER | OS.SWP_DRAWFRAME | OS.SWP_NOACTIVATE;
            SetWindowPos (handle, null, rect.left, rect.top, width, height, flags);
        }
    } else {
        if (!OS.IsWindowVisible (handle)) return;
        if (maximized is OS.IsZoomed (handle)) return;
        OS.ShowWindow (handle, swFlags);
        OS.UpdateWindow (handle);
    }
}

void _setMinimized (bool minimized) {
    static if (OS.IsWinCE) return;
    swFlags = minimized ? OS.SW_SHOWMINNOACTIVE : OS.SW_RESTORE;
    if (!OS.IsWindowVisible (handle)) return;
    if (minimized is OS.IsIconic (handle)) return;
    int flags = swFlags;
    if (flags is OS.SW_SHOWMINNOACTIVE && handle is OS.GetActiveWindow ()) {
        flags = OS.SW_MINIMIZE;
    }
    OS.ShowWindow (handle, flags);
    OS.UpdateWindow (handle);
}

void addMenu (Menu menu) {
    if (menus is null) menus = new Menu [4];
    for (int i=0; i<menus.length; i++) {
        if (menus [i] is null) {
            menus [i] = menu;
            return;
        }
    }
    Menu [] newMenus = new Menu [menus.length + 4];
    newMenus [menus.length] = menu;
    System.arraycopy (menus, 0, newMenus, 0, menus.length);
    menus = newMenus;
}

void bringToTop () {
    /*
    * This code is intentionally commented.  On some platforms,
    * the ON_TOP style creates a shell that will stay on top
    * of every other shell on the desktop.  Using SetWindowPos ()
    * with HWND_TOP caused problems on Windows 98 so this code is
    * commented out until this functionality is specified and
    * the problems are fixed.
    */
//  if ((style & DWT.ON_TOP) !is 0) {
//      int flags = OS.SWP_NOSIZE | OS.SWP_NOMOVE | OS.SWP_NOACTIVATE;
//      OS.SetWindowPos (handle, OS.HWND_TOP, 0, 0, 0, 0, flags);
//  } else {
        OS.BringWindowToTop (handle);
        // widget could be disposed at this point
//  }
}

static int checkStyle (int style) {
    if ((style & DWT.NO_TRIM) !is 0) {
        style &= ~(DWT.CLOSE | DWT.TITLE | DWT.MIN | DWT.MAX | DWT.RESIZE | DWT.BORDER);
    }
    static if (OS.IsWinCE) {
        /*
        * Feature in WinCE PPC.  WS_MINIMIZEBOX or WS_MAXIMIZEBOX
        * are not supposed to be used.  If they are, the result
        * is a button which does not repaint correctly.  The fix
        * is to remove this style.
        */
        if ((style & DWT.MIN) !is 0) style &= ~DWT.MIN;
        if ((style & DWT.MAX) !is 0) style &= ~DWT.MAX;
        return style;
    }
    if ((style & (DWT.MENU | DWT.MIN | DWT.MAX | DWT.CLOSE)) !is 0) {
        style |= DWT.TITLE;
    }

    /*
    * If either WS_MINIMIZEBOX or WS_MAXIMIZEBOX are set,
    * we must also set WS_SYSMENU or the buttons will not
    * appear.
    */
    if ((style & (DWT.MIN | DWT.MAX)) !is 0) style |= DWT.CLOSE;

    /*
    * Both WS_SYSMENU and WS_CAPTION must be set in order
    * to for the system menu to appear.
    */
    if ((style & DWT.CLOSE) !is 0) style |= DWT.TITLE;

    /*
    * Bug in Windows.  The WS_CAPTION style must be
    * set when the window is resizable or it does not
    * draw properly.
    */
    /*
    * This code is intentionally commented.  It seems
    * that this problem originally in Windows 3.11,
    * has been fixed in later versions.  Because the
    * exact nature of the drawing problem is unknown,
    * keep the commented code around in case it comes
    * back.
    */
//  if ((style & DWT.RESIZE) !is 0) style |= DWT.TITLE;

    return style;
}

override void checkBorder () {
    /* Do nothing */
}

void checkComposited (Composite parent) {
    /* Do nothing */
}

override void checkOpened () {
    if (!opened) resized = false;
}

override protected void checkSubclass () {
    if (!isValidSubclass ()) error (DWT.ERROR_INVALID_SUBCLASS);
}

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

void closeWidget () {
    Event event = new Event ();
    sendEvent (DWT.Close, event);
    if (event.doit && !isDisposed ()) dispose ();
}

int compare (ImageData data1, ImageData data2, int width, int height, int depth) {
    int value1 = Math.abs (data1.width - width), value2 = Math.abs (data2.width - width);
    if (value1 is value2) {
        int transparent1 = data1.getTransparencyType ();
        int transparent2 = data2.getTransparencyType ();
        if (transparent1 is transparent2) {
            if (data1.depth is data2.depth) return 0;
            return data1.depth > data2.depth && data1.depth <= depth ? -1 : 1;
        }
        if (!OS.IsWinCE && OS.WIN32_VERSION >= OS.VERSION (5, 1)) {
            if (transparent1 is DWT.TRANSPARENCY_ALPHA) return -1;
            if (transparent2 is DWT.TRANSPARENCY_ALPHA) return 1;
        }
        if (transparent1 is DWT.TRANSPARENCY_MASK) return -1;
        if (transparent2 is DWT.TRANSPARENCY_MASK) return 1;
        if (transparent1 is DWT.TRANSPARENCY_PIXEL) return -1;
        if (transparent2 is DWT.TRANSPARENCY_PIXEL) return 1;
        return 0;
    }
    return value1 < value2 ? -1 : 1;
}

override Control computeTabGroup () {
    return this;
}

override Control computeTabRoot () {
    return this;
}

override public Rectangle computeTrim (int x, int y, int width, int height) {
    checkWidget ();

    /* Get the size of the trimmings */
    RECT rect;
    OS.SetRect (&rect, x, y, x + width, y + height);
    int bits1 = OS.GetWindowLong (handle, OS.GWL_STYLE);
    int bits2 = OS.GetWindowLong (handle, OS.GWL_EXSTYLE);
    bool hasMenu = OS.IsWinCE ? false : OS.GetMenu (handle) !is null;
    OS.AdjustWindowRectEx (&rect, bits1, hasMenu, bits2);

    /* Get the size of the scroll bars */
    if (horizontalBar !is null) rect.bottom += OS.GetSystemMetrics (OS.SM_CYHSCROLL);
    if (verticalBar !is null) rect.right += OS.GetSystemMetrics (OS.SM_CXVSCROLL);

    /* Compute the height of the menu bar */
    if (hasMenu) {
        RECT testRect;
        OS.SetRect (&testRect, 0, 0, rect.right - rect.left, rect.bottom - rect.top);
        OS.SendMessage (handle, OS.WM_NCCALCSIZE, 0, &testRect);
        while ((testRect.bottom - testRect.top) < height) {
            if (testRect.bottom - testRect.top is 0) break;
            rect.top -= OS.GetSystemMetrics (OS.SM_CYMENU) - OS.GetSystemMetrics (OS.SM_CYBORDER);
            OS.SetRect (&testRect, 0, 0, rect.right - rect.left, rect.bottom - rect.top);
            OS.SendMessage (handle, OS.WM_NCCALCSIZE, 0, &testRect);
        }
    }
    return new Rectangle (rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
}

void createAccelerators () {
    hAccel = null;
    nAccel = 0;
    int maxAccel = 0;
    MenuItem [] items = display.items;
    if (menuBar is null || items is null) {
        if (!OS.IsPPC) return;
        maxAccel = 1;
    } else {
        maxAccel = OS.IsPPC ? items.length + 1 : items.length;
    }
    ACCEL accel;
    byte [] buffer1 = new byte [ACCEL.sizeof];
    byte [] buffer2 = new byte [maxAccel * ACCEL.sizeof];
    if (menuBar !is null && items !is null) {
        for (int i=0; i<items.length; i++) {
            MenuItem item = items [i];
            if (item !is null && item.accelerator !is 0) {
                Menu menu = item.parent;
                if (menu.parent is this) {
                    while (menu !is null && menu !is menuBar) {
                        menu = menu.getParentMenu ();
                    }
                    if (menu is menuBar && item.fillAccel (&accel)) {
                        *cast(ACCEL*)buffer1.ptr = accel;
                        //OS.MoveMemory (buffer1, accel, ACCEL.sizeof);
                        System.arraycopy (buffer1, 0, buffer2, nAccel * ACCEL.sizeof, ACCEL.sizeof);
                        nAccel++;
                    }
                }
            }
        }
    }
    if (OS.IsPPC) {
        /*
        * Note on WinCE PPC.  Close the shell when user taps CTRL-Q.
        * IDOK represents the "Done Button" which also closes the shell.
        */
        accel.fVirt = cast(byte) (OS.FVIRTKEY | OS.FCONTROL);
        accel.key = cast(short) 'Q';
        accel.cmd = cast(short) OS.IDOK;
        *cast(ACCEL*)buffer1.ptr = accel;
        //OS.MoveMemory (buffer1, accel, ACCEL.sizeof);
        System.arraycopy (buffer1, 0, buffer2, nAccel * ACCEL.sizeof, ACCEL.sizeof);
        nAccel++;
    }
    if (nAccel !is 0) hAccel = OS.CreateAcceleratorTable ( cast(ACCEL*)buffer2.ptr, nAccel);
}

override void createHandle () {
    super.createHandle ();
    if (parent !is null || ((style & DWT.TOOL) !is 0)) {
        setParent ();
        setSystemMenu ();
    }
}

override void createWidget () {
    super.createWidget ();
    swFlags = OS.IsWinCE ? OS.SW_SHOWMAXIMIZED : OS.SW_SHOWNOACTIVATE;
    hAccel = cast(HACCEL)-1;
}

void destroyAccelerators () {
    if (hAccel !is null && hAccel !is cast(HACCEL)-1) OS.DestroyAcceleratorTable (hAccel);
    hAccel = cast(HACCEL)-1;
}

override public void dispose () {
    if (isDisposed()) return;
    if (!isValidThread ()) error (DWT.ERROR_THREAD_INVALID_ACCESS);
    if (!(cast(Shell)this)) {
        if (!traverseDecorations (true)) {
            Shell shell = getShell ();
            shell.setFocus ();
        }
        setVisible (false);
    }
    super.dispose ();
}

Menu findMenu (HMENU hMenu) {
    if (menus is null) return null;
    for (int i=0; i<menus.length; i++) {
        Menu menu = menus [i];
        if (menu !is null && hMenu is menu.handle) return menu;
    }
    return null;
}

void fixDecorations (Decorations newDecorations, Control control, Menu [] menus) {
    if (this is newDecorations) return;
    if (control is savedFocus) savedFocus = null;
    if (control is defaultButton) defaultButton = null;
    if (control is saveDefault) saveDefault = null;
    if (menus is null) return;
    Menu menu = control.menu;
    if (menu !is null) {
        int index = 0;
        while (index <menus.length) {
            if (menus [index] is menu) {
                control.setMenu (null);
                return;
            }
            index++;
        }
        menu.fixMenus (newDecorations);
        destroyAccelerators ();
        newDecorations.destroyAccelerators ();
    }
}

override public Rectangle getBounds () {
    checkWidget ();
    static if (!OS.IsWinCE) {
        if (OS.IsIconic (handle)) {
            WINDOWPLACEMENT lpwndpl;
            lpwndpl.length = WINDOWPLACEMENT.sizeof;
            OS.GetWindowPlacement (handle, &lpwndpl);
            int width = lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left;
            int height = lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top;
            return new Rectangle (lpwndpl.rcNormalPosition.left, lpwndpl.rcNormalPosition.top, width, height);
        }
    }
    return super.getBounds ();
}

override public Rectangle getClientArea () {
    checkWidget ();
    /*
    * Note: The CommandBar is part of the client area,
    * not the trim.  Applications don't expect this so
    * subtract the height of the CommandBar.
    */
    static if (OS.IsHPC) {
        Rectangle rect = super.getClientArea ();
        if (menuBar !is null) {
            auto hwndCB = menuBar.hwndCB;
            int height = OS.CommandBar_Height (hwndCB);
            rect.y += height;
            rect.height = Math.max (0, rect.height - height);
        }
        return rect;
    }
    static if (!OS.IsWinCE) {
        if (OS.IsIconic (handle)) {
            WINDOWPLACEMENT lpwndpl;
            lpwndpl.length = WINDOWPLACEMENT.sizeof;
            OS.GetWindowPlacement (handle, &lpwndpl);
            int width = lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left;
            int height = lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top;
            /*
            * Feature in Windows.  For some reason WM_NCCALCSIZE does
            * not compute the client area when the window is minimized.
            * The fix is to compute it using AdjustWindowRectEx() and
            * GetSystemMetrics().
            *
            * NOTE: This code fails to compute the correct client area
            * for a minimized window where the menu bar would wrap were
            * the window restored.  There is no fix for this problem at
            * this time.
            */
            if (horizontalBar !is null) width -= OS.GetSystemMetrics (OS.SM_CYHSCROLL);
            if (verticalBar !is null) height -= OS.GetSystemMetrics (OS.SM_CXVSCROLL);
            RECT rect;
            int bits1 = OS.GetWindowLong (handle, OS.GWL_STYLE);
            int bits2 = OS.GetWindowLong (handle, OS.GWL_EXSTYLE);
            bool hasMenu = OS.IsWinCE ? false : OS.GetMenu (handle) !is null;
            OS.AdjustWindowRectEx (&rect, bits1, hasMenu, bits2);
            width = Math.max (0, width - (rect.right - rect.left));
            height = Math.max (0, height - (