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

import dwt.DWT;
import dwt.DWTError;
import dwt.DWTException;
import dwt.graphics.Color;
import dwt.graphics.Cursor;
import dwt.graphics.Device;
import dwt.graphics.DeviceData;
import dwt.graphics.Font;
import dwt.graphics.GC;
import dwt.graphics.GCData;
import dwt.graphics.Image;
import dwt.graphics.ImageData;
import dwt.graphics.PaletteData;
import dwt.graphics.Point;
import dwt.graphics.RGB;
import dwt.graphics.Rectangle;
import dwt.graphics.Resource;
import dwt.internal.ImageList;
import dwt.internal.Library;
import dwt.internal.win32.OS;

import dwt.widgets.Control;
import dwt.widgets.Dialog;
import dwt.widgets.Tray;
import dwt.widgets.Event;
import dwt.widgets.EventTable;
import dwt.widgets.Menu;
import dwt.widgets.MenuItem;
import dwt.widgets.Synchronizer;
import dwt.widgets.Monitor;
import dwt.widgets.Shell;
import dwt.widgets.Listener;
import dwt.widgets.Widget;
import dwt.widgets.TrayItem;

import dwt.dwthelper.utils;
import dwt.dwthelper.Runnable;
import dwt.dwthelper.System;
import tango.core.Thread;
import tango.stdc.stringz;
import tango.util.Convert;
static import tango.text.convert.Utf;
static import tango.text.Text;
alias tango.text.Text.Text!(char) StringBuffer;

/**
 * Instances of this class are responsible for managing the
 * connection between DWT and the underlying operating
 * system. Their most important function is to implement
 * the DWT event loop in terms of the platform event model.
 * They also provide various methods for accessing information
 * about the operating system, and have overall control over
 * the operating system resources which DWT allocates.
 * <p>
 * Applications which are built with DWT will <em>almost always</em>
 * require only a single display. In particular, some platforms
 * which DWT supports will not allow more than one <em>active</em>
 * display. In other words, some platforms do not support
 * creating a new display if one already exists that has not been
 * sent the <code>dispose()</code> message.
 * <p>
 * In DWT, the thread which creates a <code>Display</code>
 * instance is distinguished as the <em>user-interface thread</em>
 * for that display.
 * </p>
 * The user-interface thread for a particular display has the
 * following special attributes:
 * <ul>
 * <li>
 * The event loop for that display must be run from the thread.
 * </li>
 * <li>
 * Some DWT API methods (notably, most of the public methods in
 * <code>Widget</code> and its subclasses), may only be called
 * from the thread. (To support multi-threaded user-interface
 * applications, class <code>Display</code> provides inter-thread
 * communication methods which allow threads other than the
 * user-interface thread to request that it perform operations
 * on their behalf.)
 * </li>
 * <li>
 * The thread is not allowed to construct other
 * <code>Display</code>s until that display has been disposed.
 * (Note that, this is in addition to the restriction mentioned
 * above concerning platform support for multiple displays. Thus,
 * the only way to have multiple simultaneously active displays,
 * even on platforms which support it, is to have multiple threads.)
 * </li>
 * </ul>
 * Enforcing these attributes allows DWT to be implemented directly
 * on the underlying operating system's event model. This has
 * numerous benefits including smaller footprint, better use of
 * resources, safer memory management, clearer program logic,
 * better performance, and fewer overall operating system threads
 * required. The down side however, is that care must be taken
 * (only) when constructing multi-threaded applications to use the
 * inter-thread communication mechanisms which this class provides
 * when required.
 * </p><p>
 * All DWT API methods which may only be called from the user-interface
 * thread are distinguished in their documentation by indicating that
 * they throw the "<code>ERROR_THREAD_INVALID_ACCESS</code>"
 * DWT exception.
 * </p>
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>(none)</dd>
 * <dt><b>Events:</b></dt>
 * <dd>Close, Dispose, Settings</dd>
 * </dl>
 * <p>
 * IMPORTANT: This class is <em>not</em> intended to be subclassed.
 * </p>
 * @see #syncExec
 * @see #asyncExec
 * @see #wake
 * @see #readAndDispatch
 * @see #sleep
 * @see Device#dispose
 * @see <a href="http://www.eclipse.org/swt/snippets/#display">Display snippets</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */

public class Display : Device {

    /**
     * the handle to the OS message queue
     * (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 MSG* msg;

    /* Windows and Events */
    Event [] eventQueue;
    //Callback windowCallback;
    //int windowProc_;
    int threadId;
    TCHAR[] windowClass_, windowShadowClass;
    static int WindowClassCount;
    static const String WindowName = "SWT_Window"; //$NON-NLS-1$
    static const String WindowShadowName = "SWT_WindowShadow"; //$NON-NLS-1$
    EventTable eventTable, filterTable;

    /* Widget Table */
    int freeSlot;
    int [] indexTable;
    Control lastControl, lastGetControl;
    HANDLE lastHwnd;
    HWND lastGetHwnd;
    Control [] controlTable;
    static const int GROW_SIZE = 1024;
    private static /+const+/ int SWT_OBJECT_INDEX;
    static const bool USE_PROPERTY = !OS.IsWinCE;

    private static bool static_this_completed = false;
    private static void static_this() {
        if( static_this_completed ){
            return;
        }
        synchronized {
            if( static_this_completed ){
                return;
            }
            static if (USE_PROPERTY) {
                SWT_OBJECT_INDEX = OS.GlobalAddAtom (StrToTCHARz("SWT_OBJECT_INDEX")); //$NON-NLS-1$
            } else {
                SWT_OBJECT_INDEX = 0;
            }
            static_this_StartupInfo ();
            static_this_DeviceFinder ();
            static_this_completed = true;
        }
    }

    /* Startup info */
    private static STARTUPINFO* lpStartupInfo;
    private static void static_this_StartupInfo (){
        static if (!OS.IsWinCE) {
            lpStartupInfo = new STARTUPINFO ();
            lpStartupInfo.cb = STARTUPINFO.sizeof;
            OS.GetStartupInfo (lpStartupInfo);
        }
    }
    /* XP Themes */
    HTHEME hButtonTheme_, hEditTheme_, hExplorerBarTheme_, hScrollBarTheme_, hTabTheme_;
    static const wchar [] BUTTON = "BUTTON\0"w;
    static const wchar [] EDIT = "EDIT\0"w;
    static const wchar [] EXPLORER = "EXPLORER\0"w;
    static const wchar [] EXPLORERBAR = "EXPLORERBAR\0"w;
    static const wchar [] SCROLLBAR = "SCROLLBAR\0"w;
    static const wchar [] LISTVIEW = "LISTVIEW\0"w;
    static const wchar [] TAB = "TAB\0"w;
    static const wchar [] TREEVIEW = "TREEVIEW\0"w;

    /* Focus */
    int focusEvent;
    Control focusControl;

    /* Menus */
    Menu [] bars, popups;
    MenuItem [] items;

    /*
    * The start value for WM_COMMAND id's.
    * Windows reserves the values 0..100.
    *
    * The SmartPhone DWT resource file reserves
    * the values 101..107.
    */
    static const int ID_START = 108;

    /* Filter Hook */
    //Callback msgFilterCallback;
    //int msgFilterProc_,
    HHOOK filterHook;
    bool runDragDrop = true, dragCancelled = false;
    MSG* hookMsg;

    /* Idle Hook */
    //Callback foregroundIdleCallback;
    //int foregroundIdleProc_;
    HHOOK idleHook;

    /* Message Hook and Embedding */
    bool ignoreNextKey;
    //Callback getMsgCallback, embeddedCallback;
    int getMsgProc_;
    HHOOK msgHook;
    HWND embeddedHwnd;
    int embeddedProc_;
    static const String AWT_WINDOW_CLASS = "SunAwtWindow";
    static const short [] ACCENTS = [ cast(short) '~', '`', '\'', '^', '"'];

    /* Sync/Async Widget Communication */
    Synchronizer synchronizer;
    bool runMessages = true, runMessagesInIdle = false, runMessagesInMessageProc = true;
    static const String RUN_MESSAGES_IN_IDLE_KEY = "org.eclipse.swt.internal.win32.runMessagesInIdle"; //$NON-NLS-1$
    static final String RUN_MESSAGES_IN_MESSAGE_PROC_KEY = "dwt.internal.win32.runMessagesInMessageProc"; //$NON-NLS-1$
    Thread thread;

    /* Display Shutdown */
    Runnable [] disposeList;

    /* System Tray */
    Tray tray;
    int nextTrayId;

    /* Timers */
    int /*long*/ [] timerIds;
    Runnable [] timerList;
    int /*long*/ nextTimerId = SETTINGS_ID + 1;
    static const int SETTINGS_ID = 100;
    static const int SETTINGS_DELAY = 2000;

    /* Keyboard and Mouse */
    RECT* clickRect;
    int clickCount, lastTime, lastButton;
    HWND lastClickHwnd;
    int scrollRemainder;
    int lastKey, lastAscii, lastMouse;
    bool lastVirtual, lastNull, lastDead;
    ubyte [256] keyboard;
    bool accelKeyHit, mnemonicKeyHit;
    bool lockActiveWindow, captureChanged, xMouse;

    /* Tool Tips */
    int nextToolTipId;

    /* MDI */
    bool ignoreRestoreFocus;
    Control lastHittestControl;
    int lastHittest;

    /* Message Only Window */
    HWND hwndMessage;

    /* System Resources */
    LOGFONT* lfSystemFont;
    Font systemFont;
    Image errorImage, infoImage, questionImage, warningIcon;
    Cursor [] cursors;
    Resource [] resources;
    static const int RESOURCE_SIZE = 1 + 4 + DWT.CURSOR_HAND + 1;

    /* ImageList Cache */
    ImageList[] imageList, toolImageList, toolHotImageList, toolDisabledImageList;

    /* Custom Colors for ChooseColor */
    COLORREF* lpCustColors;

    /* Sort Indicators */
    Image upArrow, downArrow;

    /* Table */
    char [] tableBuffer;
    NMHDR* hdr;
    NMLVDISPINFO* plvfi;
    HWND hwndParent;
    int columnCount;
    bool [] columnVisible;

    /* Resize and move recursion */
    int resizeCount;
    static final int RESIZE_LIMIT = 4;

    /* Display Data */
    Object data;
    String [] keys;
    Object [] values;

    /* Key Mappings */
    static const int [] [] KeyTable = [

        /* Keyboard and Mouse Masks */
        [OS.VK_MENU,    DWT.ALT],
        [OS.VK_SHIFT,   DWT.SHIFT],
        [OS.VK_CONTROL, DWT.CONTROL],
//      [OS.VK_????,    DWT.COMMAND],

        /* NOT CURRENTLY USED */
//      [OS.VK_LBUTTON, DWT.BUTTON1],
//      [OS.VK_MBUTTON, DWT.BUTTON3],
//      [OS.VK_RBUTTON, DWT.BUTTON2],

        /* Non-Numeric Keypad Keys */
        [OS.VK_UP,      DWT.ARROW_UP],
        [OS.VK_DOWN,    DWT.ARROW_DOWN],
        [OS.VK_LEFT,    DWT.ARROW_LEFT],
        [OS.VK_RIGHT,   DWT.ARROW_RIGHT],
        [OS.VK_PRIOR,   DWT.PAGE_UP],
        [OS.VK_NEXT,    DWT.PAGE_DOWN],
        [OS.VK_HOME,    DWT.HOME],
        [OS.VK_END,     DWT.END],
        [OS.VK_INSERT,  DWT.INSERT],

        /* Virtual and Ascii Keys */
        [OS.VK_BACK,    DWT.BS],
        [OS.VK_RETURN,  DWT.CR],
        [OS.VK_DELETE,  DWT.DEL],
        [OS.VK_ESCAPE,  DWT.ESC],
        [OS.VK_RETURN,  DWT.LF],
        [OS.VK_TAB,     DWT.TAB],

        /* Functions Keys */
        [OS.VK_F1,  DWT.F1],
        [OS.VK_F2,  DWT.F2],
        [OS.VK_F3,  DWT.F3],
        [OS.VK_F4,  DWT.F4],
        [OS.VK_F5,  DWT.F5],
        [OS.VK_F6,  DWT.F6],
        [OS.VK_F7,  DWT.F7],
        [OS.VK_F8,  DWT.F8],
        [OS.VK_F9,  DWT.F9],
        [OS.VK_F10, DWT.F10],
        [OS.VK_F11, DWT.F11],
        [OS.VK_F12, DWT.F12],
        [OS.VK_F13, DWT.F13],
        [OS.VK_F14, DWT.F14],
        [OS.VK_F15, DWT.F15],

        /* Numeric Keypad Keys */
        [OS.VK_MULTIPLY,    DWT.KEYPAD_MULTIPLY],
        [OS.VK_ADD,         DWT.KEYPAD_ADD],
        [OS.VK_RETURN,      DWT.KEYPAD_CR],
        [OS.VK_SUBTRACT,    DWT.KEYPAD_SUBTRACT],
        [OS.VK_DECIMAL,     DWT.KEYPAD_DECIMAL],
        [OS.VK_DIVIDE,      DWT.KEYPAD_DIVIDE],
        [OS.VK_NUMPAD0,     DWT.KEYPAD_0],
        [OS.VK_NUMPAD1,     DWT.KEYPAD_1],
        [OS.VK_NUMPAD2,     DWT.KEYPAD_2],
        [OS.VK_NUMPAD3,     DWT.KEYPAD_3],
        [OS.VK_NUMPAD4,     DWT.KEYPAD_4],
        [OS.VK_NUMPAD5,     DWT.KEYPAD_5],
        [OS.VK_NUMPAD6,     DWT.KEYPAD_6],
        [OS.VK_NUMPAD7,     DWT.KEYPAD_7],
        [OS.VK_NUMPAD8,     DWT.KEYPAD_8],
        [OS.VK_NUMPAD9,     DWT.KEYPAD_9],
//      [OS.VK_????,        DWT.KEYPAD_EQUAL],

        /* Other keys */
        [OS.VK_CAPITAL,     DWT.CAPS_LOCK],
        [OS.VK_NUMLOCK,     DWT.NUM_LOCK],
        [OS.VK_SCROLL,      DWT.SCROLL_LOCK],
        [OS.VK_PAUSE,       DWT.PAUSE],
        [OS.VK_CANCEL,      DWT.BREAK],
        [OS.VK_SNAPSHOT,    DWT.PRINT_SCREEN],
//      [OS.VK_????,        DWT.HELP],

    ];

    /* Multiple Displays */
    static Display Default;
    static Display [] Displays;

    /* Multiple Monitors */
    dwt.widgets.Monitor.Monitor[] monitors = null;
    int monitorCount = 0;

    /* Modality */
    Shell [] modalShells;
    Dialog modalDialog;
    static bool TrimEnabled = false;

    /* Private DWT Window Messages */
    static const int SWT_GETACCELCOUNT  = OS.WM_APP;
    static const int SWT_GETACCEL       = OS.WM_APP + 1;
    static const int SWT_KEYMSG         = OS.WM_APP + 2;
    static const int SWT_DESTROY        = OS.WM_APP + 3;
    static const int SWT_TRAYICONMSG    = OS.WM_APP + 4;
    static const int SWT_NULL           = OS.WM_APP + 5;
    static const int SWT_RUNASYNC       = OS.WM_APP + 6;
    static int SWT_TASKBARCREATED;
    static int SWT_RESTORECARET;
    static int DI_GETDRAGIMAGE;

    /* Workaround for Adobe Reader 7.0 */
    int hitCount;

    /* Package Name */
    static const String PACKAGE_PREFIX = "org.eclipse.swt.widgets."; //$NON-NLS-1$
    /*
    * This code is intentionally commented.  In order
    * to support CLDC, .class cannot be used because
    * it does not compile on some Java compilers when
    * they are targeted for CLDC.
    */
//  static {
//      String name = Display.class.getName ();
//      int index = name.lastIndexOf ('.');
//      PACKAGE_PREFIX = name.substring (0, index + 1);
//  }

    /*
    * TEMPORARY CODE.  Install the runnable that
    * gets the current display. This code will
    * be removed in the future.
    */
    private static void static_this_DeviceFinder () {
        DeviceFinder = new class() Runnable {
            public void run () {
                Device device = getCurrent ();
                if (device is null) {
                    device = getDefault ();
                }
                setDevice (device);
            }
        };
    }

/*
* TEMPORARY CODE.
*/
static void setDevice (Device device) {
    static_this();
    CurrentDevice = device;
}

/**
 * Constructs a new instance of this class.
 * <p>
 * Note: The resulting display is marked as the <em>current</em>
 * display. If this is the first display which has been
 * constructed since the application started, it is also
 * marked as the <em>default</em> display.
 * </p>
 *
 * @exception DWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if called from a thread that already created an existing display</li>
 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
 * </ul>
 *
 * @see #getCurrent
 * @see #getDefault
 * @see Widget#checkSubclass
 * @see Shell
 */
public this () {
    this (null);
}

/**
 * Constructs a new instance of this class using the parameter.
 *
 * @param data the device data
 */
public this (DeviceData data) {
    static_this();
    msg = new MSG();
    hookMsg = new MSG();
    super (data);
    synchronizer = new Synchronizer (this);
    cursors = new Cursor [DWT.CURSOR_HAND + 1];
}

Control _getFocusControl () {
    return findControl (OS.GetFocus ());
}

void addBar (Menu menu) {
    if (bars is null) bars = new Menu [4];
    int length_ = bars.length;
    for (int i=0; i<length_; i++) {
        if (bars [i] is menu) return;
    }
    int index = 0;
    while (index < length_) {
        if (bars [index] is null) break;
        index++;
    }
    if (index is length_) {
        Menu [] newBars = new Menu [length_ + 4];
        System.arraycopy (bars, 0, newBars, 0, length_);
        bars = newBars;
    }
    bars [index] = menu;
}

void addControl (HANDLE handle, Control control) {
    if (handle is null) return;
    if (freeSlot is -1) {
        int length_ = (freeSlot = indexTable.length) + GROW_SIZE;
        int [] newIndexTable = new int [length_];
        Control [] newControlTable = new Control [length_];
        System.arraycopy (indexTable, 0, newIndexTable, 0, freeSlot);
        System.arraycopy (controlTable, 0, newControlTable, 0, freeSlot);
        for (int i=freeSlot; i<length_-1; i++) newIndexTable [i] = i + 1;
        newIndexTable [length_ - 1] = -1;
        indexTable = newIndexTable;
        controlTable = newControlTable;
    }
    static if (USE_PROPERTY) {
        OS.SetProp (handle, cast(wchar*)SWT_OBJECT_INDEX, cast(void*) freeSlot + 1);
    } else {
        OS.SetWindowLongPtr (handle, OS.GWLP_USERDATA, freeSlot + 1);
    }
    int oldSlot = freeSlot;
    freeSlot = indexTable [oldSlot];
    indexTable [oldSlot] = -2;
    controlTable [oldSlot] = control;
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when an event of the given type occurs anywhere
 * in a widget. The event type is one of the event constants
 * defined in class <code>DWT</code>. When the event does occur,
 * the listener is notified by sending it the <code>handleEvent()</code>
 * message.
 * <p>
 * Setting the type of an event to <code>DWT.None</code> from
 * within the <code>handleEvent()</code> method can be used to
 * change the event type and stop subsequent Java listeners
 * from running. Because event filters run before other listeners,
 * event filters can both block other listeners and set arbitrary
 * fields within an event. For this reason, event filters are both
 * powerful and dangerous. They should generally be avoided for
 * performance, debugging and code maintenance reasons.
 * </p>
 *
 * @param eventType the type of event to listen for
 * @param listener the listener which should be notified when the event occurs
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 *    <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 *
 * @see Listener
 * @see DWT
 * @see #removeFilter
 * @see #removeListener
 *
 * @since 3.0
 */
public void addFilter (int eventType, Listener listener) {
    checkDevice ();
    if (listener is null) error (DWT.ERROR_NULL_ARGUMENT);
    if (filterTable is null) filterTable = new EventTable ();
    filterTable.hook (eventType, listener);
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when an event of the given type occurs. The event
 * type is one of the event constants defined in class <code>DWT</code>.
 * When the event does occur in the display, the listener is notified by
 * sending it the <code>handleEvent()</code> message.
 *
 * @param eventType the type of event to listen for
 * @param listener the listener which should be notified when the event occurs
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 *    <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 *
 * @see Listener
 * @see DWT
 * @see #removeListener
 *
 * @since 2.0
 */
public void addListener (int eventType, Listener listener) {
    checkDevice ();
    if (listener is null) error (DWT.ERROR_NULL_ARGUMENT);
    if (eventTable is null) eventTable = new EventTable ();
    eventTable.hook (eventType, listener);
}

void addMenuItem (MenuItem item) {
    if (items is null) items = new MenuItem [64];
    for (int i=0; i<items.length; i++) {
        if (items [i] is null) {
            item.id = i + ID_START;
            items [i] = item;
            return;
        }
    }
    item.id = items.length + ID_START;
    MenuItem [] newItems = new MenuItem [items.length + 64];
    newItems [items.length] = item;
    System.arraycopy (items, 0, newItems, 0, items.length);
    items = newItems;
}

void addPo