/*******************************************************************************

 * Copyright (c) 2000, 2007 IBM Corporation and others.

 * Portion Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

 * 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

 *      Nokia Corporation - Qt implementation

 *******************************************************************************/

package org.eclipse.swt.widgets;

import org.eclipse.ercp.swt.mobile.Internal_MobilePackageSupport;

import org.eclipse.ercp.swt.mobile.MobileDevice;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Device;

import org.eclipse.swt.graphics.DeviceData;

import org.eclipse.swt.graphics.Internal_GfxPackageSupport;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.internal.ApplicationUidWrapper;

import org.eclipse.swt.internal.ExitNotificationWrapper;

import org.eclipse.swt.internal.qt.CommandArranger;

import org.eclipse.swt.internal.qt.GCData;

import org.eclipse.swt.internal.qt.JniUtils;

import org.eclipse.swt.internal.qt.OS;

import org.eclipse.swt.internal.qt.QObjectDeleteWrapper;

import org.eclipse.swt.internal.qt.SharedGCWrapper;

import org.eclipse.swt.internal.qt.WidgetState;

import org.eclipse.swt.internal.qt.graphics.GraphicsContext;

/**

 * Instances of this class are responsible for managing the

 * connection between SWT and the underlying operating

 * system. Their most important function is to implement

 * the SWT 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 SWT allocates.

 * <p>

 * Applications which are built with SWT will <em>almost always</em>

 * require only a single display. In particular, some platforms

 * which SWT 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 SWT, 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 SWT 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 SWT 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 SWT 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>"

 * SWT 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

 */

public class Display extends Device {

/* QApplication */

static int handle;

/* QApplication event filter */

static int eventFilterHandle;

static final String SWT_OBJECT_INDEX = "swt_obj_idx";

static final String ADD_WIDGET_KEY = "org.eclipse.swt.internal.addWidget";

static final String REMOVE_WIDGET_KEY = "org.eclipse.swt.internal.removeWidget";

static final String IMAGE_LOAD_SIZE_KEY = "org.eclipse.swt.internal.image.loadSize";

static final String SWT_EVENT_FILTER = "swt_event_filter";

static CommandArranger commandArranger;

static Event[] eventQueue;

static EventTable eventTable, filterTable;

static String APP_NAME;

/* Widget Table */

static int[] indexTable;

static int freeSlot;

static int lastHandle;

static Widget lastWidget;

static Widget[] widgetTable;

final static int GROW_SIZE = 64;

static MobileDevice mobileDevice;

static int mobileDeviceHandle;

/* Modality */

static Shell [] modalShells;

static Dialog modalDialog;

/* Sync/Async Widget Communication */

static Synchronizer synchronizer;

Thread thread;

static Thread fixedUiThread;

/* Display Shutdown */

Runnable [] disposeList;

/* System Tray */

static Tray tray;

/* Timers */

static int [] timerHandles;

static Runnable [] timerRunnables;

/* Timestamp of the Last Received Event */

static int lastEventTime;

/* If not to interrupt event processing after every event */

static boolean noInterrupt;

/* Used to block one type of events temporarily */

static int blockedQtEventType;

/* Default orientation for Controls when style is not specified */

static int defaultOrientation;

static boolean defaultOrientationIsSysLangDirection;

// The next Image loaded by Image class constructors will be scaled to

// this size. Can be set using Display.setData([key], Point). Useful

// for SVG images. 

static private Point imageLoadSize;

/* Key Mappings */

static final int [] [] KeyTable = {

    /* Keyboard and Mouse Masks */

    {OS.QT_KEY_ALT,     SWT.ALT},

    {OS.QT_KEY_ALTGR,   SWT.ALT},

    {OS.QT_KEY_META,    SWT.ALT},

    {OS.QT_KEY_SHIFT,   SWT.SHIFT},

    {OS.QT_KEY_CONTROL, SWT.CONTROL},

    /* Non-Numeric Keypad Keys */

    {OS.QT_KEY_UP,      SWT.ARROW_UP},

    {OS.QT_KEY_DOWN,    SWT.ARROW_DOWN},

    {OS.QT_KEY_LEFT,    SWT.ARROW_LEFT},

    {OS.QT_KEY_RIGHT,   SWT.ARROW_RIGHT},

    {OS.QT_KEY_PAGEUP,  SWT.PAGE_UP},

    {OS.QT_KEY_PAGEDOWN,SWT.PAGE_DOWN},

    {OS.QT_KEY_HOME,    SWT.HOME},

    {OS.QT_KEY_END,     SWT.END},

    {OS.QT_KEY_INSERT,  SWT.INSERT},

    /* Virtual and Ascii Keys */

    {OS.QT_KEY_BACKSPACE,SWT.BS},

    {OS.QT_KEY_RETURN,   SWT.CR},

    {OS.QT_KEY_DELETE,   SWT.DEL},

    {OS.QT_KEY_ESCAPE,   SWT.ESC},

    {OS.QT_KEY_ENTER,    SWT.CR},

    {OS.QT_KEY_TAB,      SWT.TAB},

    {OS.QT_KEY_BACKTAB,  SWT.TAB},

    /* Functions Keys */

    {OS.QT_KEY_F1,      SWT.F1},

    {OS.QT_KEY_F2,      SWT.F2},

    {OS.QT_KEY_F3,      SWT.F3},

    {OS.QT_KEY_F4,      SWT.F4},

    {OS.QT_KEY_F5,      SWT.F5},

    {OS.QT_KEY_F6,      SWT.F6},

    {OS.QT_KEY_F7,      SWT.F7},

    {OS.QT_KEY_F8,      SWT.F8},

    {OS.QT_KEY_F9,      SWT.F9},

    {OS.QT_KEY_F10,     SWT.F10},

    {OS.QT_KEY_F11,     SWT.F11},

    {OS.QT_KEY_F12,     SWT.F12},

    {OS.QT_KEY_F13,     SWT.F13},

    {OS.QT_KEY_F14,     SWT.F14},

    {OS.QT_KEY_F15,     SWT.F15},

    /* Other keys */

    {OS.QT_KEY_CAPSLOCK,    SWT.CAPS_LOCK},

    {OS.QT_KEY_NUMLOCK,     SWT.NUM_LOCK},

    {OS.QT_KEY_SCROLLLOCK,  SWT.SCROLL_LOCK},

    {OS.QT_KEY_PAUSE,       SWT.PAUSE},

    {OS.QT_KEY_PRINT,       SWT.PRINT_SCREEN},

    {OS.QT_KEY_HELP,        SWT.HELP},

};

/*

 * Feature in QT: The key events that are result of keypad

 * are indicated with the QT_KEYPADMODIFIER. Therefore

 * we have a second key table to map only the KeyPad keys.

 */

static final int [] [] KeyPadKeyTable = {

    /* Numeric Keypad Keys */

    {OS.QT_KEY_ASTERISK,        SWT.KEYPAD_MULTIPLY},

    {OS.QT_KEY_PLUS,            SWT.KEYPAD_ADD},

    {OS.QT_KEY_ENTER,           SWT.KEYPAD_CR},

    {OS.QT_KEY_MINUS,   SWT.KEYPAD_SUBTRACT},

    {OS.QT_KEY_PERIOD,  SWT.KEYPAD_DECIMAL},

    {OS.QT_KEY_SLASH,       SWT.KEYPAD_DIVIDE},

    {OS.QT_KEY_0,           SWT.KEYPAD_0},

    {OS.QT_KEY_1,           SWT.KEYPAD_1},

    {OS.QT_KEY_2,           SWT.KEYPAD_2},

    {OS.QT_KEY_3,           SWT.KEYPAD_3},

    {OS.QT_KEY_4,           SWT.KEYPAD_4},

    {OS.QT_KEY_5,           SWT.KEYPAD_5},

    {OS.QT_KEY_6,           SWT.KEYPAD_6},

    {OS.QT_KEY_7,           SWT.KEYPAD_7},

    {OS.QT_KEY_8,           SWT.KEYPAD_8},

    {OS.QT_KEY_9,           SWT.KEYPAD_9},

    {OS.QT_KEY_EQUAL,   SWT.KEYPAD_EQUAL},

};

/*

 * Virtual key codes for control keys on X11.

 */

static final int X11_SHIFT_LEFT    = 0xffe1;

static final int X11_SHIFT_RIGHT   = 0xffe2;

static final int X11_CONTROL_LEFT  = 0xffe3;

static final int X11_CONTROL_RIGHT = 0xffe4;

static final int X11_META_LEFT     = 0xffe7;

static final int X11_META_RIGHT    = 0xffe8;

static final int X11_ALT_LEFT      = 0xffe9;

static final int X11_ALT_RIGHT     = 0xffea;

static final int X11_SUPER_LEFT    = 0xffeb;

static final int X11_SUPER_RIGHT   = 0xffec;

static final int X11_HYPER_LEFT    = 0xffed;

static final int X11_HYPER_RIGHT   = 0xffee;

/*

 * Scan codes for control keys on Symbian.

 */

static final int SYMBIAN_SHIFT_LEFT  = 0x12;    // EStdKeyLeftShift

static final int SYMBIAN_SHIFT_RIGHT = 0x13;    // EStdKeyRightShift

static final int SYMBIAN_ALT_LEFT    = 0x14;    // EStdKeyLeftAlt

static final int SYMBIAN_ALT_RIGHT   = 0x15;    // EStdKeyRightAlt

static final int SYMBIAN_CTRL_LEFT   = 0x16;    // EStdKeyLeftCtrl

static final int SYMBIAN_CTRL_RIGHT  = 0x17;    // EStdKeyRightCtrl

static final int SYMBIAN_FN_LEFT     = 0x18;    // EStdKeyLeftFunc

static final int SYMBIAN_FN_RIGHT    = 0x19;    // EStdKeyRightFunc

/* Multiple Displays. */

static Display Default;

static Display Internal;

static Display [] Displays = new Display [4];

/* Package name */

static final String PACKAGE_PREFIX = "org.eclipse.swt.widgets.";

/* eRCP package name */

static final String ERCP_MOBILE_PACKAGE_PREFIX = "org.eclipse.ercp.swt.mobile.";

/* extension package name */

static final String INTERNAL_EXTENSION_PACKAGE_PREFIX = "org.eclipse.swt.internal.extension.";

/* Display Data */

static Object data;

static String [] keys;

static Object [] values;

/* Last ShortcutOverride event parameters */

static int shortcutOverrideKey;

static int shortcutOverrideModifier;

static int shortcutOverrideCharacter;

/* Last control that had a mnemonic hit i.e. shortcut event*/

static Control mnemonicControl;

/* It is stored here if we are currently in a focus event */

static int focusEvent;

/* Settings event specific variables */

static final int SETTINGS_DELAY = 2000;

static Runnable settingsRunnable;

/**

 * 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 SWTException <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 </li>

 * </ul>

 *

 * @see #getCurrent

 * @see #getDefault

 * @see Widget#checkSubclass

 * @see Shell

 */

public Display () {

    this (null);

}

/**

 * Constructs a new instance of this class using the parameter.

 *

 * @param data the device data

 */

public Display (DeviceData data) {

    super(data);

}

private Display(DeviceData data, boolean internal) {

	super(data, internal);

}

static Display internalInstance() {

	if(Internal == null) {

		Internal = new Display(null, true);

	}

	return Internal;

}

/**

 * 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>SWT</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>SWT.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 SWTException <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 SWT

 * @see #removeFilter

 * @see #removeListener

 *

 * @since 3.0

 */

public void addFilter (int eventType, Listener listener) {

    checkDevice ();

    if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);

    if (filterTable == 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>SWT</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 SWTException <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 SWT

 * @see #removeListener

 *

 * @since 2.0

 */

public void addListener (int eventType, Listener listener) {

    checkDevice ();

    if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);

    if (eventTable == null) eventTable = new EventTable ();

    eventTable.hook (eventType, listener);

}

static void addWidget (int handle, Widget widget) {

    if (handle == 0) return;

    if (freeSlot == -1) {

        int length = (freeSlot = indexTable.length) + GROW_SIZE;

        int[] newIndexTable = new int[length];

        Widget[] newWidgetTable = new Widget [length];

        System.arraycopy (indexTable, 0, newIndexTable, 0, freeSlot);

        System.arraycopy (widgetTable, 0, newWidgetTable, 0, freeSlot);

        for (int i = freeSlot; i < length - 1; i++) {

            newIndexTable[i] = i + 1;

        }

        newIndexTable[length - 1] = -1;

        indexTable = newIndexTable;

        widgetTable = newWidgetTable;

    }

    int index = freeSlot + 1;

    OS.QObject_setProperty(handle, SWT_OBJECT_INDEX, index);

    int oldSlot = freeSlot;

    freeSlot = indexTable[oldSlot];

    indexTable [oldSlot] = -2;

    widgetTable [oldSlot] = widget;

}

/**

 * Causes the <code>run()</code> method of the runnable to

 * be invoked by the user-interface thread at the next

 * reasonable opportunity. The caller of this method continues

 * to run in parallel, and is not notified when the

 * runnable has completed.  Specifying <code>null</code> as the

 * runnable simply wakes the user-interface thread when run.

 * <p>

 * Note that at the time the runnable is invoked, widgets

 * that have the receiver as their display may have been

 * disposed. Therefore, it is necessary to check for this

 * case inside the runnable before accessing the widget.

 * </p>

 *

 * @param runnable code to run on the user-interface thread or <code>null</code>

 *

 * @exception SWTException <ul>

 *    <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>

 * </ul>

 *

 * @see #syncExec

 */

public void asyncExec (Runnable runnable) {

    synchronized (Device.class) {

        if (isDisposed ()) error (SWT.ERROR_DEVICE_DISPOSED);

        synchronizer.asyncExec (runnable);

    }

}

/**

 * Causes the system hardware to emit a short sound

 * (if it supports this capability).

 *

 * @exception SWTException <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>

 */

public void beep () {

    if (!isValidThread ()) error (SWT.ERROR_THREAD_INVALID_ACCESS);

    OS.QApplication_beep();

}

private static void checkDefaultOrientation(int sysLangDirection) {

    defaultOrientation = SWT.LEFT_TO_RIGHT;

    String s = System.getProperty("org.eclipse.ercp.swt.defaultOrientation");

    if (s != null) {

        if (s.equals("system")) {

            defaultOrientation = sysLangDirection;

            defaultOrientationIsSysLangDirection = true;

        } else if (s.equals("rtl")) {

            defaultOrientation = SWT.RIGHT_TO_LEFT;

        }

    }

}

protected void checkDevice () {

    if (thread == null) error (SWT.ERROR_WIDGET_DISPOSED);

    if (thread != Thread.currentThread ()) error (SWT.ERROR_THREAD_INVALID_ACCESS);

    if (isDisposed ()) error (SWT.ERROR_DEVICE_DISPOSED);

}

final void checkDisplay (Thread thread, boolean multiple) {