FCL/sf/app/jrt: comparison javauis/eswt_qt/org.eclipse.swt/Eclipse SWT/qt/org/eclipse/swt/widgets/Display.java

equal deleted inserted replaced

-:dc7c549001d5
+:85266cc22c7f
 /* QApplication */
 static int handle;
 /* QApplication event filter */
-int eventFilterHandle;
+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";
-public CommandArranger commandArranger;
+static CommandArranger commandArranger;
-Event[] eventQueue;
+static Event[] eventQueue;
-EventTable eventTable, filterTable;
+static EventTable eventTable, filterTable;
-// Note that this won't work with multiple displays in the same process.
-// All the displays will have the same appname.
 static String APP_NAME;
 /* Widget Table */
-int[] indexTable;
+static int[] indexTable;
-int freeSlot;
+static int freeSlot;
-int lastHandle;
+static int lastHandle;
-Widget lastWidget;
+static Widget lastWidget;
-Widget[] widgetTable;
+static Widget[] widgetTable;
 final static int GROW_SIZE = 64;
-MobileDevice mobileDevice;
+static MobileDevice mobileDevice;
-int mobileDeviceHandle;
+static int mobileDeviceHandle;
 /* Modality */
-Shell [] modalShells;
+static Shell [] modalShells;
-Dialog modalDialog;
+static Dialog modalDialog;
 /* Sync/Async Widget Communication */
-Synchronizer synchronizer = new Synchronizer (this);
+static Synchronizer synchronizer;
 Thread thread;
 static Thread fixedUiThread;
 /* Display Shutdown */
 Runnable [] disposeList;
 /* System Tray */
-Tray tray;
+static Tray tray;
 /* Timers */
-int [] timerHandles;
+static int [] timerHandles;
-Runnable [] timerRunnables;
+static Runnable [] timerRunnables;
 /* Timestamp of the Last Received Event */
-int lastEventTime;
+static int lastEventTime;
 /* If not to interrupt event processing after every event */
-boolean noInterrupt;
+static boolean noInterrupt;
 /* Used to block one type of events temporarily */
-int blockedQtEventType;
+static int blockedQtEventType;
 /* Default orientation for Controls when style is not specified */
-int defaultOrientation;
+static int defaultOrientation;
-boolean defaultOrientationIsSysLangDirection;
+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.
-private Point imageLoadSize;
+static private Point imageLoadSize;
 /* Key Mappings */
 static final int [] [] KeyTable = {
 /* Keyboard and Mouse Masks */
 {OS.QT_KEY_ALT,     SWT.ALT},
 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.";
 /* extension package name */
 static final String INTERNAL_EXTENSION_PACKAGE_PREFIX = "org.eclipse.swt.internal.extension.";
 /* Display Data */
-Object data;
+static Object data;
-String [] keys;
+static String [] keys;
-Object [] values;
+static Object [] values;
 /* Last ShortcutOverride event parameters */
-int shortcutOverrideKey;
+static int shortcutOverrideKey;
-int shortcutOverrideModifier;
+static int shortcutOverrideModifier;
-int shortcutOverrideCharacter;
+static int shortcutOverrideCharacter;
 /* Last control that had a mnemonic hit i.e. shortcut event*/
-Control mnemonicControl;
+static Control mnemonicControl;
 /* It is stored here if we are currently in a focus event */
-int focusEvent;
+static int focusEvent;
 /* Settings event specific variables */
 static final int SETTINGS_DELAY = 2000;
-Runnable settingsRunnable;
+static Runnable settingsRunnable;
-/*
-* TEMPORARY CODE.  Install the runnable that
-* gets the current display. This code will
-* be removed in the future.
-*/
-static {
-DeviceFinder = new Runnable () {
-public void run () {
-Device device = getCurrent ();
-if (device == null) {
-device = getDefault ();
-}
-setDevice (device);
-}
-};
-}
-/*
-* TEMPORARY CODE.
-*/
-static void setDevice (Device device) {
-CurrentDevice = device;
-}
 /**
 * Constructs a new instance of this class.
 * <p>
 * Note: The resulting display is marked as the <em>current</em>
 *
 * @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
 if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);
 if (eventTable == null) eventTable = new EventTable ();
 eventTable.hook (eventType, listener);
 }
-void addWidget (int handle, Widget widget) {
+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];
 public void beep () {
 if (!isValidThread ()) error (SWT.ERROR_THREAD_INVALID_ACCESS);
 OS.QApplication_beep();
 }
-private void checkDefaultOrientation(int sysLangDirection) {
+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;
 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);
 }
-static void checkDisplay (Thread thread, boolean multiple) {
+final void checkDisplay (Thread thread, boolean multiple) {
 synchronized (Device.class) {
 for (int i=0; i<Displays.length; i++) {
 if (Displays [i] != null) {
-if (!multiple) SWT.error (SWT.ERROR_NOT_IMPLEMENTED, null, " [multiple displays]");
+	if(Internal_GfxPackageSupport.internal(this) == Internal_GfxPackageSupport.internal(Displays[i])) {
-if (Displays [i].thread == thread) SWT.error (SWT.ERROR_THREAD_INVALID_ACCESS);
+		if (!multiple) SWT.error (SWT.ERROR_NOT_IMPLEMENTED, null, " [multiple displays]");
+if (Displays [i].thread == thread) SWT.error (SWT.ERROR_THREAD_INVALID_ACCESS);
+	}
 }
 }
 // On some platforms it's not supported to dispose the Display and
 // create another one in a different thread. Once a Display is created
 // in a thread that thread becomes the UI thread of the process and no
 if(OS.windowServer == OS.WS_SYMBIAN_S60 && fixedUiThread == null) fixedUiThread = thread;
 if (fixedUiThread != null && !fixedUiThread.equals(thread)) SWT.error (SWT.ERROR_THREAD_INVALID_ACCESS);
 }
 }
-void checkSubclass () {
+final void checkSubclass () {
 if (!isValidClass (getClass ())) error (SWT.ERROR_INVALID_SUBCLASS);
 }
-void clearModal (Shell shell) {
+final void clearModal (Shell shell) {
 if (modalShells == null) return;
 int index = 0, length = modalShells.length;
 while (index < length) {
 if (modalShells [index] == shell) break;
 if (modalShells [index] == null) return;
 Event event = new Event ();
 sendEvent (SWT.Close, event);
 if (event.doit) dispose ();
 }
-void createDisplay() {
+static void createDisplay() {
 // It's possible that there's already a QApplication from an old Display
 // that has been disposed in an event listener but we were unable to delete
 // the QApplication there. If we are creating this Display from an event
 // listener too then this won't help.
 tryDestroy();
 // Perform the required initialisation before Qt APIs can be used.
 if(OS.initUiThread(ApplicationUidWrapper.uid()) != 0) SWT.error(SWT.ERROR_UNSPECIFIED);
 // Create the object that manages the JNI activity. It's only possible when
 // this object exists.
-JniUtils.handle = OS.JniUtils_new(this);
+JniUtils.handle = OS.JniUtils_new();
 handle = OS.QApplication_swt_new(JniUtils.handle);
 if(handle == 0) SWT.error(SWT.ERROR_UNSPECIFIED);
 OS.QApplication_setQuitOnLastWindowClosed(false);
 * </p>
 * @see Device#dispose
 * @see #release
 */
 protected void destroy () {
-if (this == Default) Default = null;
+boolean notifyExit;
+	if (notifyExit = (this == Default)) {
+	Default = null;
+} else if(this == Internal) {
+	Internal = null;
+}
 deregister (this);
-GraphicsContext sharedGc = SharedGCWrapper.getSharedGC();
+if(Default == null && Internal == null) {
-if(sharedGc != null && !sharedGc.isDisposed()) sharedGc.dispose();
+	    GraphicsContext sharedGc = SharedGCWrapper.getSharedGC();
-destroyDisplay ();
+	    if(sharedGc != null && !sharedGc.isDisposed()) sharedGc.dispose();
+	    destroyDisplay ();
+	    super.destroy();
+}
+if(notifyExit) {
+// Notify MIDP runtime to watch that the MIDlet exits.
+// For other runtime environments this does nothing.
+ExitNotificationWrapper.notifyExit();
+}
 }
 void destroyDisplay () {
 OS.QObject_removeEventFilter(handle, eventFilterHandle);
 OS.EventHandler_destroy(eventFilterHandle);
 OS.QApplication_syncX();
 tryDestroy();
+}
-// Notify MIDP runtime to watch that the MIDlet exits.
-// For other runtime environments this does nothing.
+int displayCount() {
-ExitNotificationWrapper.notifyExit();
+int res = 0;
+for (int i = 0; i < Displays.length; i++) {
+if (Displays[i] != null && !Displays[i].isDisposed()) {
+res++;
+}
+}
+return res;
 }
 /**
 * Causes the <code>run()</code> method of the runnable to
 * be invoked by the user-interface thread just before the
 }
 /*
 * This is the main event handler that is called by native code.
 */
-final boolean eventProcess(int widgetHandle, int eventType, int time,
+static boolean eventProcess(int widgetHandle, int eventType, int time,
 int arg1, int arg2, int arg3, int arg4, int arg5, String arg6) {
 // Silently let blocked events through
 if(blockedQtEventType == eventType) return false;
 // This goes to time field of the events that possibly get sent
 lastEventTime = time;
 // Get target widget or null if not found or is the Display
 Widget widget = ((widgetHandle == handle) ? null : getWidget ( widgetHandle ));
-if(!noInterrupt && !isDisposed()) {
+if(!noInterrupt) {
 interrupt();
 }
 if (eventType < OS.QSIGNAL_ID_RANGE_FIRST) {
 return handleQtEvent(widget, widgetHandle, eventType, arg1, arg2,
 return handleQtSignal(widget, widgetHandle, eventType, arg1, arg2,
 arg3, arg4, arg5, arg6);
 }
 }
-boolean filterEvent (Event event) {
+static boolean filterEvent (Event event) {
 if (filterTable != null) filterTable.sendEvent (event);
 return false;
 }
-boolean filters (int eventType) {
+static boolean filters (int eventType) {
 if (filterTable == null) return false;
 return filterTable.hooks (eventType);
 }
-Control findControl (int handle) {
+static Control findControl (int handle) {
 if (handle == 0) return null;
 do {
 Widget widget = getWidget (handle);
 if(widget != null && widget instanceof Control) return (Control)widget;
 handle = OS.QObject_parent(handle);
 */
 public static Display findDisplay (Thread thread) {
 synchronized (Device.class) {
 for (int i=0; i<Displays.length; i++) {
 Display display = Displays [i];
-if (display != null && display.thread == thread) {
+if (display != null && display.thread == thread && !Internal_GfxPackageSupport.internal(display)) {
 return display;
 }
 }
 return null;
 }
 // Ignoring base implementation
 checkDevice ();
 return OS.QDesktopWidget_availableGeometry(OS.QApplication_desktop(), -1);
 }
-Control[] getControls()
+static Control[] getControls()
 {
 // Create a table of all Controls, no duplicates
 Control controlTable[] = new Control[widgetTable.length];
 int controlTableIndex = 0;
 for(int i = 0; i < widgetTable.length; i++) {
 public Control getFocusControl () {
 checkDevice ();
 return _getFocusControl ();
 }
-Control _getFocusControl () {
+static Control _getFocusControl () {
 return findControl( OS.QApplication_focusWidget() );
 }
 /**
 * Returns the maximum allowed depth of icons on this display, in bits per pixel.
 public int getIconDepth () {
 checkDevice ();
 return super.getDepth();
 }
-int getLastEventTime () {
+static int getLastEventTime () {
 return lastEventTime;
 }
-int getMessageCount () {
+static int getMessageCount () {
 return synchronizer.getMessageCount ();
 }
-Dialog getModalDialog () {
+static Dialog getModalDialog () {
 return modalDialog;
 }
-Menu[] getMenus()
+static Menu[] getMenus()
 {
 // Create a table of all Menus, no duplicates
 Menu menuTable[] = new Menu[widgetTable.length];
 int menuTableIndex = 0;
 for(int i = 0; i < widgetTable.length; i++) {
 *    <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 */
 public Shell [] getShells () {
 checkDevice ();
+return getShells_();
+}
+static Shell[] getShells_() {
 int index = 0;
 Shell [] result = new Shell [16];
 for (int i = 0; i < widgetTable.length; i++) {
 Widget widget = widgetTable [i];
 if (widget != null && widget instanceof Shell) {
 }
 }
 if (index == result.length) return result;
 Shell [] newResult = new Shell [index];
 System.arraycopy (result, 0, newResult, 0, index);
 return newResult;
 }
 /**
 * Returns the thread that has invoked <code>syncExec</code>
 * or null if no such runnable is currently being invoked by
 if (isDisposed ()) error (SWT.ERROR_DEVICE_DISPOSED);
 return thread;
 }
 }
-private final int getTimerHandleIndex(int timerHandle) {
+private static int getTimerHandleIndex(int timerHandle) {
 if(timerHandles == null) return -1;
 int index;
 for(index = 0; index < timerHandles.length; ++index) {
 if(timerHandles[index] == timerHandle) {
 return index;
 }
 }
 return -1;
 }
-Widget getWidget (int handle) {
+static Widget getWidget (int handle) {
 if (handle == 0) return null;
 if (lastWidget != null && lastHandle == handle) return lastWidget;
 int index = OS.QObject_property( handle, SWT_OBJECT_INDEX) - 1;
 if (0 <= index && index < widgetTable.length) {
 lastHandle = handle;
 return lastWidget = widgetTable [(int)index];
 }
 return null;
 }
-final private boolean handleNativeSwtEvent(Widget widget, int widgetHandle,
+static private boolean handleNativeSwtEvent(Widget widget, int widgetHandle,
 int eventType, int time, int arg1, int arg2, int arg3, int arg4,
 int arg5) {
 switch (eventType) {
 case OS.QSWTEVENT_SYSTEMSHUTDOWN:
 default:
 return false;
 }
 }
-final private boolean handleQtEvent(Widget widget, int widgetHandle, int eventType,
+static private boolean handleQtEvent(Widget widget, int widgetHandle, int eventType,
 int arg1, int arg2, int arg3, int arg4, int arg5) {
 // These events are coming from an application event filter of QApplication.
 // The return value of this method will be returned by the filter.
 if (eventType == OS.QEVENT_KEYPRESS && arg1 == OS.QT_KEY_NO) {
-qt_key_event_endKeyPressed();
+	qt_key_event_endKeyPressed();
 return false;
 }
 if (widget == null) {
 return false;
 }
 switch (eventType) {
 default:
 return false;
 }
 }
-final private boolean handleQtSignal(Widget widget, int widgetHandle,
+static private boolean handleQtSignal(Widget widget, int widgetHandle,
 int eventType, int arg1, int arg2, int arg3, int arg4, int arg5,
 String arg6) {
 // Note that return values here are meaningless. Signals are already
 // coming from the widgets and won't be passed to anywhere after this.
 default:
 return false;
 }
 }
-void hookEvents() {
+static void hookEvents() {
-int focusSignalProxy = OS.SignalHandler_new(handle, this, OS.QSIGNAL_QAPPLICATION_FOCUSCHANGED);
+int focusSignalProxy = OS.SignalHandler_new(handle, OS.QSIGNAL_QAPPLICATION_FOCUSCHANGED);
 OS.QObject_connectOrThrow(handle, "focusChanged(QWidget*, QWidget*)", focusSignalProxy,
 "widgetSignal(QWidget*, QWidget*)", OS.QT_AUTOCONNECTION);
 }
 protected void init () {
 checkSubclass ();
 checkDisplay(thread = Thread.currentThread (), false);
-createDisplay();
+if(!Internal_GfxPackageSupport.initialized()) {
-commandArranger = new CommandArranger();
+	createDisplay();
+	    synchronizer = new Synchronizer (this);
+	    commandArranger = new CommandArranger(this);
+}
 register (this);
-if (Default == null) Default = this;
+if (Default == null && !Internal_GfxPackageSupport.internal(this)) Default = this;
 super.init ();
-initializeWidgetTable ();
+if(!Internal_GfxPackageSupport.initialized()) {
-}
+	initializeWidgetTable ();
+}
-void initializeWidgetTable () {
+}
+static void initializeWidgetTable () {
 indexTable = new int [GROW_SIZE];
 widgetTable = new Widget [GROW_SIZE];
 for (int i=0; i<GROW_SIZE-1; i++) indexTable [i] = i + 1;
 indexTable [GROW_SIZE - 1] = -1;
 }
 data.buffered = false;
 data.internalGc.bindTarget(this);
 return data.internalGc.getHandle();
 }
-void interrupt() {
+static void interrupt() {
 /*
 * Try to interrupt to make the native event processing methods return. By
 * default Qt processes all available events in one iteration. This is
 * a problem e.g. when an exception has been thrown in a listener. It
 * depends on the event dispatcher implementation what this actually does.
 * It might be that interrupting is only possible between native UI main
 * event loop iterations and in each iteration several QEvents can get
 * dispatched.
 */
-int threadHandle = OS.QObject_thread( Display.handle );
+	synchronized(Device.class) {
-int dispatcher = OS.QAbstractEventDispatcher_instance( threadHandle );
+		if(handle == 0) return;
-OS.QAbstractEventDispatcher_interrupt( dispatcher );
+	}
+int threadHandle = OS.QObject_thread(handle);
+int dispatcher = OS.QAbstractEventDispatcher_instance(threadHandle);
+OS.QAbstractEventDispatcher_interrupt(dispatcher);
 }
 static boolean isValidClass (Class clazz) {
 String name = clazz.getName();
 int index = name.lastIndexOf('.');
 }
 return false;
 }
-void postEvent (Event event) {
+static void postEvent (Event event) {
 /*
 * Place the event at the end of the event queue.
 * This code is always called in the Display's
 * thread so it must be re-enterant but does not
 * need to be synchronized.
 eventQueue = newQueue;
 }
 eventQueue [index] = event;
 }
-void qt_signal_qapplication_focusChanged(int old, int now) {
+static void qt_signal_qapplication_focusChanged(int old, int now) {
 Widget oldWidget = null, nowWidget = null;
 if(old != 0) oldWidget = getWidget(old);
 if(now != 0) nowWidget = getWidget(now);
 nowWidget.qt_swt_event_focusWasGained();
 }
 }
-void qt_signal_timer (int timerHandleIndex) {
+static void qt_signal_timer (int timerHandleIndex) {
 if (timerRunnables == null || timerHandles == null) return;
 Runnable runnable = timerRunnables [timerHandleIndex];
 timerRunnables [timerHandleIndex] = null;
 timerHandles [timerHandleIndex] = 0;
 if (runnable != null) runnable.run ();
 }
+static void qt_key_event_endKeyPressed() {
-void qt_key_event_endKeyPressed(){
+Event event = new Event ();
-close();
+sendEvent (SWT.Close, event);
-}
+if (event.doit) {
+	if(Default != null) {
+		Default.dispose ();
-void qt_swt_event_systemShutdown(){
+	}
+}
+}
+static void qt_swt_event_systemShutdown(){
 Event event = new Event ();
 sendEvent (SWT.Close, event);
 ExitNotificationWrapper.notifyExit();
 }
 /**
 * Reads an event from the operating system's event queue,
 * dispatches it appropriately, and returns <code>true</code>
 * if there is potentially more work to do, or <code>false</code>
 return false;
 }
 return asyncRetVal;
 }
-Point readAndClearImageLoadSize() {
+static Point readAndClearImageLoadSize() {
-	Point imageLoadSize = this.imageLoadSize;
+	Point ilSize = Display.imageLoadSize;
-	this.imageLoadSize = null;
+	Display.imageLoadSize = null;
-	return imageLoadSize;
+	return ilSize;
 }
 static void register (Display display) {
 synchronized (Device.class) {
 for (int i=0; i<Displays.length; i++) {
 Shell [] shells = getShells ();
 for (int i=0; i<shells.length; i++) {
 Shell shell = shells [i];
 if (!shell.isDisposed ())  shell.dispose ();
 }
-commandArranger.dispose();
+final boolean lastDisplay = (displayCount() == 1);
-if (tray != null) tray.dispose ();
+if(lastDisplay) {
-tray = null;
+	    commandArranger.dispose();
+	    if (tray != null) tray.dispose ();
+	    tray = null;
+}
 while (readAndDispatch ()) {}
 if (disposeList != null) {
 for (int i=0; i<disposeList.length; i++) {
 if (disposeList [i] != null) disposeList [i].run ();
 }
 }
+if(lastDisplay) {
+	    synchronizer.releaseSynchronizer ();
+	    synchronizer = null;
+	    lastWidget = null;
+	    indexTable = null;
+	    widgetTable = null;
+}
+thread = null;
 disposeList = null;
-synchronizer.releaseSynchronizer ();
-synchronizer = null;
-thread = null;
-lastWidget = null;
-indexTable = null;
-widgetTable = null;
 super.release ();
 }
 /**
 * Removes the listener from the collection of listeners who will
 if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);
 if (eventTable == null) return;
 eventTable.unhook (eventType, listener);
 }
-Widget removeWidget (int handle) {
+static Widget removeWidget (int handle) {
 if (handle == 0) return null;
 lastWidget = null;
 Widget widget = null;
 int index = (int)/*64*/ OS.QObject_property( handle, SWT_OBJECT_INDEX ) - 1;
 if (0 <= index && index < widgetTable.length) {
 final private boolean repostFailedQEvents() {
 OS.SwtApplication_postDeferredEvents();
 return disposed;
 }
-boolean runAsyncMessages (boolean all) {
+static boolean runAsyncMessages (boolean all) {
 return synchronizer.runAsyncMessages (all);
 }
-boolean runDeferredEvents () {
+static boolean runDeferredEvents () {
 /*
 * Run deferred events.  This code is always
 * called in the Display's thread so it must
 * be re-entrant but need not be synchronized.
 */
 /* Clear the queue */
 eventQueue = null;
 return true;
 }
-void runSettings () {
+static void runSettings () {
 Control[] controls = getControls();
 updateImages(controls);
 updateLayoutDirections(controls);
 sendEvent(SWT.Settings, null);
 for(int i = 0; i < controls.length; i++) {
 controls[i].doRedraw();
 }
-Shell [] shells = getShells ();
+Shell [] shells = getShells_();
 for(int i = 0; i < shells.length; i++) {
 Shell shell = shells [i];
 if(!shell.isDisposed ()) {
 shell.layout(true, true);
 }
 final private boolean sendDeferredDeletionQEvents() {
 OS.QCoreApplication_sendPostedEvents(handle, 0, OS.QEVENT_DEFERREDDELETE);
 return disposed;
 }
-void sendEvent (int eventType, Event event) {
+static void sendEvent (int eventType, Event event) {
 if (eventTable == null && filterTable == null) {
 return;
 }
 if (event == null) event = new Event ();
-event.display = this;
+event.display = Default;
 event.type = eventType;
 if (event.time == 0) event.time = getLastEventTime ();
 if (!filterEvent (event)) {
 if (eventTable != null) eventTable.sendEvent (event);
 }
 final private boolean sendQEvents() {
 OS.QCoreApplication_processEvents( handle, OS.QEVENTLOOP_ALLEVENTS);
 return disposed;
 }
-final private void sendSettings()
+static private void sendSettings() {
-{
+Display instance = Default != null ? Default : Internal;
-if(settingsRunnable != null) {
+	if(settingsRunnable != null) {
 // Cancel the existing timer
-timerExec(-1, settingsRunnable);
+instance.timerExec(-1, settingsRunnable);
 }
-timerExec(SETTINGS_DELAY, settingsRunnable = new Runnable() {
+instance.timerExec(SETTINGS_DELAY, settingsRunnable = new Runnable() {
 public void run() {
 runSettings();
 settingsRunnable = null;
 }
 });
 *
 * @param name the new app name or <code>null</code>
 */
 public static void setAppName (String name) {
 APP_NAME = name;
-if (Display.getCurrent() != null) {
+if (Display.handle != 0 && (!Default.disposed || !Internal.disposed)) {
 OS.QCoreApplication_setApplicationName(handle, name);
 OS.setSymbianAppName(name);
 }
 }
 * @see #getData()
 * @see #disposeExec(Runnable)
 */
 public void setData (Object data) {
 checkDevice ();
-this.data = data;
+Display.data = data;
 }
-void setScreenPaintingAttributes(boolean on) {
+static void setScreenPaintingAttributes(boolean on) {
 OS.QWidget_setAttribute(OS.QApplication_desktop(), OS.QT_WA_PAINTOUTSIDEPAINTEVENT, on);
 OS.QWidget_setAttribute(OS.QApplication_desktop(), OS.QT_WA_PAINTONSCREEN, on);
 OS.QWidget_setAttribute(OS.QApplication_desktop(), OS.QT_WA_PAINTUNCLIPPED, on);
 }
-void setModalDialog (Dialog modalDialog) {
+static void setModalDialog (Dialog modalDialog) {
-this.modalDialog = modalDialog;
+Display.modalDialog = modalDialog;
-Shell [] shells = getShells ();
+Shell [] shells = getShells_();
 for (int i=0; i<shells.length; i++) shells [i].updateModal ();
 }
-void setModalShell (Shell shell) {
+static void setModalShell (Shell shell) {
 if (modalShells == null) modalShells = new Shell [4];
 int index = 0, length = modalShells.length;
 while (index < length) {
 if (modalShells [index] == shell) return;
 if (modalShells [index] == null) break;
 Shell [] newModalShells = new Shell [length + 4];
 System.arraycopy (modalShells, 0, newModalShells, 0, length);
 modalShells = newModalShells;
 }
 modalShells [index] = shell;
-Shell [] shells = getShells ();
+Shell [] shells = getShells_();
 for (int i=0; i<shells.length; i++) shells [i].updateModal ();
 }
 /**
 * Sets the synchronizer used by the display to be
 * </ul>
 */
 public void setSynchronizer (Synchronizer synchronizer) {
 checkDevice ();
 if (synchronizer == null) error (SWT.ERROR_NULL_ARGUMENT);
-if (synchronizer == this.synchronizer) return;
+if (synchronizer == Display.synchronizer) return;
 Synchronizer oldSynchronizer;
 synchronized (Device.class) {
-oldSynchronizer = this.synchronizer;
+oldSynchronizer = Display.synchronizer;
-this.synchronizer = synchronizer;
+Display.synchronizer = synchronizer;
 }
 if (oldSynchronizer != null) {
 oldSynchronizer.runAsyncMessages(true);
 }
 }
 */
 public void syncExec (Runnable runnable) {
 Synchronizer synchronizer;
 synchronized (Device.class) {
 if (isDisposed ()) error (SWT.ERROR_DEVICE_DISPOSED);
-synchronizer = this.synchronizer;
+synchronizer = Display.synchronizer;
 }
 synchronizer.syncExec (runnable);
 }
 /**
 int timerHandle = OS.QTimer_new();
 if (timerHandle != 0) {
 OS.QObject_setParent(timerHandle, handle); // QTimer is a child of QApplication
 OS.QTimer_setSingleShot(timerHandle, true);
-int signalProxy = OS.SignalHandler_new(timerHandle, this, OS.QSIGNAL_TIMEOUT);
+int signalProxy = OS.SignalHandler_new(timerHandle, OS.QSIGNAL_TIMEOUT);
 OS.QObject_connectOrThrow(timerHandle, "timeout()", signalProxy, "widgetSignal()", OS.QT_AUTOCONNECTION);
 OS.QTimer_start(timerHandle, milliseconds);
 timerHandles [index] = timerHandle;
 timerRunnables [index] = runnable;
 }
 }
 // Converts single mouse button from Qt to SWT for the MouseEvent.button
 // field which takes integers, 1, 2, 3, ...
-static final int translateButton(int nativeButton) {
+static int translateButton(int nativeButton) {
 switch(nativeButton) {
 case OS.QT_LEFTBUTTON:
 return 1;
 case OS.QT_MIDBUTTON:
 return 2;
 return 0;
 }
 }
 // Converts a mask of buttons from Qt to SWT
-static final int translateButtons(int buttons) {
+static int translateButtons(int buttons) {
 int state = 0;
 if((buttons & OS.QT_LEFTBUTTON) != 0) state |= SWT.BUTTON1;
 if((buttons & OS.QT_MIDBUTTON) != 0) state |= SWT.BUTTON2;
 if((buttons & OS.QT_RIGHTBUTTON) != 0) state |= SWT.BUTTON3;
 return state;
 }
 // Converts keys from Qt to SWT
-static final int translateKey (int key, boolean keypad ) {
+static int translateKey (int key, boolean keypad ) {
 if( keypad ){
 for (int i=0; i<KeyPadKeyTable.length; i++) {
 if (KeyPadKeyTable [i] [0] == key) return KeyPadKeyTable [i] [1];
 }
 }
 }
 return 0;
 }
 // Converts modifiers from Qt to SWT
-static final int translateModifiers(int nativeModifiers) {
+static int translateModifiers(int nativeModifiers) {
 int modifiers = 0;
 if ((nativeModifiers & OS.QT_ALTMODIFIER) != 0) modifiers |= SWT.ALT;
 if ((nativeModifiers & OS.QT_SHIFTMODIFIER) != 0) modifiers |= SWT.SHIFT;
 if ((nativeModifiers & OS.QT_CONTROLMODIFIER) != 0) modifiers |= SWT.CONTROL;
 return modifiers;
 }
-static final int translateDirection(int orientation) {
+static int translateDirection(int orientation) {
 if(orientation ==  OS.QT_RIGHTTOLEFT) {
 return SWT.RIGHT_TO_LEFT;
 } else {
 return SWT.LEFT_TO_RIGHT;
 }
 }
 // Converts native scan code to key location (left/right) for CTRL/ALT/SHIFT/etc
-static final int translateKeyLocation(int nativeScanCode) {
+static int translateKeyLocation(int nativeScanCode) {
 if(OS.windowServer == OS.WS_SYMBIAN_S60) {
 switch (nativeScanCode) {
 case SYMBIAN_SHIFT_LEFT:    //intentional fall through
 case SYMBIAN_ALT_LEFT:
 }
 return 0;
 }
-private final void tryDestroy() {
+private static void tryDestroy() {
+	// Do nothing if there are Displays that have not been disposed
+	if((Default != null && !Default.disposed) ||
+			(Internal != null && !Internal.disposed)) {
+		return;
+	}
 // Destroy the QApplication only when all event loops have exited.
 if(handle != 0 && OS.SwtApplication_javaCallbackCount() == 0) {
 	OS.QApplication_closeAllWindows();
 OS.cleanUpUiThread();
 }
 }
 // Converts mouse buttons from SWT to Qt
-static final int unTranslateButton(int button) {
+static int unTranslateButton(int button) {
 switch(button) {
 case 1:
 return OS.QT_LEFTBUTTON;
 case 2:
 return OS.QT_MIDBUTTON;
 return OS.QT_NOBUTTON;
 }
 }
 // Converts event types from SWT to Qt
-static final int unTranslateEventType(int type) {
+static int unTranslateEventType(int type) {
 switch (type) {
 case SWT.KeyDown:
 return OS.QEVENT_KEYPRESS;
 case SWT.KeyUp:
 return OS.QEVENT_KEYRELEASE;
 return 0;
 }
 }
 // Converts keys from SWT to Qt
-public final static int untranslateKey (int key) {
+static int untranslateKey (int key) {
 for (int i=0; i<KeyTable.length; i++) {
 if (KeyTable [i] [1] == key) return KeyTable [i] [0];
 }
 for (int i=0; i<KeyPadKeyTable.length; i++) {
 if (KeyPadKeyTable [i] [1] == key) return KeyPadKeyTable [i] [0];
 }
 return 0;
 }
 // Converts modifiers from SWT to Qt
-static final int unTranslateModifiers(int modifiers) {
+static int unTranslateModifiers(int modifiers) {
 int nativeModifiers = 0;
 if ((modifiers & SWT.ALT) != 0) nativeModifiers |= OS.QT_ALTMODIFIER;
 if ((modifiers & SWT.SHIFT) != 0) nativeModifiers |= OS.QT_SHIFTMODIFIER;
 if ((modifiers & SWT.CONTROL) != 0) nativeModifiers |= OS.QT_CONTROLMODIFIER;
 return nativeModifiers;
 if (OS.QCoreApplication_hasPendingEvents(handle)) {
 OS.QCoreApplication_processEvents(handle, OS.QEVENTLOOP_EXCLUDEUSERINPUTEVENTS);
 }
 }
-void updateImages (Control[] controls) {
+static void updateImages (Control[] controls) {
 for(int i = 0; i < controls.length; ++i) {
 controls[i].updateImages();
 }
 }
-void updateLayoutDirection(Widget widget) {
+static void updateLayoutDirection(Widget widget) {
 // If the widget doesn't follow system language direction then leave it
 if((widget.state & WidgetState.FOLLOWS_SYSLANG_DIRECTION) != 0) {
 // Update the style flags. We already know LEFT_TO_RIGHT flag is not
 // set because if it was the widget wouldn't be following the system
 // language direction.
 OS.QWidget_setLayoutDirection(widget.topHandle,
 defaultOrientation == SWT.RIGHT_TO_LEFT ? OS.QT_RIGHTTOLEFT : OS.QT_LEFTTORIGHT);
 }
 }
-void updateLayoutDirections(Control[] controls) {
+static void updateLayoutDirections(Control[] controls) {
 if(!defaultOrientationIsSysLangDirection) return;
 // Update the default orientation
 defaultOrientation = translateDirection(OS.QApplication_layoutDirection());
 if (thread == Thread.currentThread ()) return;
 wakeThread ();
 }
 }
-void wakeThread () {
+static void wakeThread () {
 int threadHandle = OS.QObject_thread( Display.handle );
 int dispatcher = OS.QAbstractEventDispatcher_instance( threadHandle );
 OS.QAbstractEventDispatcher_wakeup( dispatcher );
 }
-int initializeMobileDevice(){
+static int initializeMobileDevice(){
 	if(mobileDeviceHandle == 0){
 		mobileDeviceHandle = OS.MobileDevice_new();
 	}
 	return mobileDeviceHandle;
 }

changeset 35	85266cc22c7f
parent 26	dc7c549001d5
child 47	f40128debb5d
child 49	35baca0e7a2e