+ * Applications which are built with SWT will almost always
+ * require only a single display. In particular, some platforms
+ * which SWT supports will not allow more than one active
+ * display. In other words, some platforms do not support
+ * creating a new display if one already exists that has not been
+ * sent the dispose() message.
+ *
+ * In SWT, the thread which creates a Display
+ * instance is distinguished as the user-interface thread
+ * for that display.
+ *
Widget and its subclasses), may only be called
+ * from the thread. (To support multi-threaded user-interface
+ * applications, class Display provides inter-thread
+ * communication methods which allow threads other than the
+ * user-interface thread to request that it perform operations
+ * on their behalf.)
+ * Displays 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.)
+ * + * 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. + *
+ * 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 "ERROR_THREAD_INVALID_ACCESS"
+ * SWT exception.
+ *
+ * IMPORTANT: This class is not intended to be subclassed. + *
+ * @see #syncExec + * @see #asyncExec + * @see #wake + * @see #readAndDispatch + * @see #sleep + * @see Device#dispose + * @see Display snippets + * @see Sample code and further information + * @noextend This class is not intended to be subclassed by clients. + */ +public class Display extends Device { + + /** + * the handle to the OS message queue + * (Warning: This field is platform dependent) + *+ * IMPORTANT: This field is not part of the SWT + * public API. It is marked public only so that it can be shared + * within the packages provided by SWT. It is not available on all + * platforms and should never be accessed from application code. + *
+ * + * @noreference This field is not intended to be referenced by clients. + */ + public MSG msg = new MSG (); + + static String APP_NAME = "SWT"; //$NON-NLS-1$ + static String APP_VERSION = ""; //$NON-NLS-1$ + + /* Windows and Events */ + Event [] eventQueue; + Callback windowCallback; + long windowProc; + int threadId; + TCHAR windowClass, windowShadowClass, windowOwnDCClass; + static int WindowClassCount; + static final String WindowName = "SWT_Window"; //$NON-NLS-1$ + static final String WindowShadowName = "SWT_WindowShadow"; //$NON-NLS-1$ + static final String WindowOwnDCName = "SWT_WindowOwnDC"; //$NON-NLS-1$ + EventTable eventTable, filterTable; + boolean useOwnDC; + boolean externalEventLoop; // events are dispatched outside SWT, e.g. TrackPopupMenu or DoDragDrop + + /* Widget Table */ + int freeSlot; + int [] indexTable; + Control lastControl, lastGetControl; + long lastHwnd, lastGetHwnd; + Control [] controlTable; + static final int GROW_SIZE = 1024; + static final int SWT_OBJECT_INDEX = OS.GlobalAddAtom (new TCHAR (0, "SWT_OBJECT_INDEX", true)); //$NON-NLS-1$ + + /* Startup info */ + static STARTUPINFO lpStartupInfo; + static { + lpStartupInfo = new STARTUPINFO (); + lpStartupInfo.cb = STARTUPINFO.sizeof; + OS.GetStartupInfo (lpStartupInfo); + } + + /* XP Themes */ + long hButtonTheme, hEditTheme, hExplorerBarTheme, hScrollBarTheme, hTabTheme; + static final char [] BUTTON = new char [] {'B', 'U', 'T', 'T', 'O', 'N', 0}; + static final char [] EDIT = new char [] {'E', 'D', 'I', 'T', 0}; + static final char [] EXPLORER = new char [] {'E', 'X', 'P', 'L', 'O', 'R', 'E', 'R', 0}; + static final char [] EXPLORERBAR = new char [] {'E', 'X', 'P', 'L', 'O', 'R', 'E', 'R', 'B', 'A', 'R', 0}; + static final char [] SCROLLBAR = new char [] {'S', 'C', 'R', 'O', 'L', 'L', 'B', 'A', 'R', 0}; + static final char [] LISTVIEW = new char [] {'L', 'I', 'S', 'T', 'V', 'I', 'E', 'W', 0}; + static final char [] TAB = new char [] {'T', 'A', 'B', 0}; + static final char [] TREEVIEW = new char [] {'T', 'R', 'E', 'E', 'V', 'I', 'E', 'W', 0}; + + /* Custom icons */ + long hIconSearch; + long hIconCancel; + + /* Focus */ + int focusEvent; + Control focusControl; + boolean fixFocus; + + /* Menus */ + Menu [] bars, popups; + MenuItem [] items; + + /* + * The start value for WM_COMMAND id's. + * Windows reserves the values 0..100. + * + * The SmartPhone SWT resource file reserves + * the values 101..107. + */ + static final int ID_START = 108; + + /* Filter Hook */ + Callback msgFilterCallback; + long msgFilterProc, filterHook; + MSG hookMsg = new MSG (); + boolean runDragDrop = true, dragCancelled = false; + + /* Idle Hook */ + Callback foregroundIdleCallback; + long foregroundIdleProc, idleHook; + + /* Message Hook and Embedding */ + boolean ignoreNextKey; + Callback getMsgCallback, embeddedCallback; + long getMsgProc, msgHook, embeddedHwnd, embeddedProc; + static final String AWT_WINDOW_CLASS = "SunAwtWindow"; //$NON-NLS-1$ + static final short [] ACCENTS = new short [] {'~', '`', '\'', '^', '"'}; + + /* Sync/Async Widget Communication */ + Synchronizer synchronizer = new Synchronizer (this); + Consumer+ * Note: The resulting display is marked as the current + * display. If this is the first display which has been + * constructed since the application started, it is also + * marked as the default display. + *
+ * + * @exception SWTExceptionSWT. When the event does occur,
+ * the listener is notified by sending it the handleEvent()
+ * message.
+ *
+ * Setting the type of an event to SWT.None from
+ * within the handleEvent() 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.
+ *
SWT.
+ * When the event does occur in the display, the listener is notified by
+ * sending it the handleEvent() message.
+ *
+ * @param eventType the type of event to listen for
+ * @param listener the listener which should be notified when the event occurs
+ *
+ * @exception IllegalArgumentException null as the
+ * runnable simply wakes the user-interface thread when run.
+ * + * 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. + *
+ * + * @param runnable code to run on the user-interface thread ornull
+ *
+ * @exception SWTException
+ * IMPORTANT: See the comment in Widget.checkSubclass().
+ *
+ * This method is called before init.
+ *
release.
+ *
+ * @see Device#dispose
+ * @see #release
+ */
+@Override
+protected void destroy () {
+ if (this == Default) Default = null;
+ deregister (this);
+ destroyDisplay ();
+}
+
+void destroyDisplay () {
+}
+
+/**
+ * Causes the run() method of the runnable to
+ * be invoked by the user-interface thread just before the
+ * receiver is disposed. Specifying a null runnable
+ * is ignored.
+ *
+ * @param runnable code to run at dispose time.
+ *
+ * @exception SWTException Widget subclass which
+ * represents it in the currently running application, if
+ * such exists, or null if no matching widget can be found.
+ * + * IMPORTANT: This method should not be called from + * application code. The arguments are platform-specific. + *
+ * + * @param handle the handle for the widget + * @return the SWT widget that the handle represents + * + * @exception SWTExceptionWidget subclass which represents
+ * the handle/id pair in the currently running application,
+ * if such exists, or null if no matching widget can be found.
+ * + * IMPORTANT: This method should not be called from + * application code. The arguments are platform-specific. + *
+ * + * @param handle the handle for the widget + * @param id the id for the subwidget (usually an item) + * @return the SWT widget that the handle/id pair represents + * + * @exception SWTExceptionWidget subclass which represents
+ * the widget/id pair in the currently running application,
+ * if such exists, or null if no matching widget can be found.
+ *
+ * @param widget the widget
+ * @param id the id for the subwidget (usually an item)
+ * @return the SWT subwidget (usually an item) that the widget/id pair represents
+ *
+ * @exception SWTException null as the thread will return null
+ * for the display.
+ *
+ * @param thread the user-interface thread
+ * @return the display for the given thread
+ */
+public static Display findDisplay (Thread thread) {
+ synchronized (Device.class) {
+ for (int i=0; inull if there is no application menu bar for the platform.
+ *
+ * @return the application menu bar, or null
+ *
+ * @exception SWTException null
+ *
+ * @exception SWTException
+ * Applications may have associated arbitrary objects with the
+ * receiver in this fashion. If the objects stored in the
+ * properties need to be notified when the display is disposed
+ * of, it is the application's responsibility to provide a
+ * disposeExec() handler which does so.
+ *
+ * Applications may put arbitrary objects in this field. If
+ * the object stored in the display specific data needs to
+ * be notified when the display is disposed of, it is the
+ * application's responsibility to provide a
+ * disposeExec() handler which does so.
+ *
LEFT or RIGHT.
+ * The button dismissal alignment is the ordering that should be used when positioning the
+ * default dismissal button for a dialog. For example, in a dialog that contains an OK and
+ * CANCEL button, on platforms where the button dismissal alignment is LEFT, the
+ * button ordering should be OK/CANCEL. When button dismissal alignment is RIGHT,
+ * the button ordering should be CANCEL/OK.
+ *
+ * @return the button dismissal order
+ *
+ * @exception SWTException null
+ *
+ * @exception SWTException + * Note: This operation is a hint and is not supported on + * platforms that do not have this concept. + *
+ * + * @return the high contrast mode + * + * @exception SWTExceptiontrue if the current OS theme has a dark appearance, else
+ * returns false.
+ * + * Note: This operation is a hint and is not supported on platforms that do not + * have this concept. + *
+ *+ * Note: Windows 10 onwards users can separately configure the theme for OS and + * Application level and this can be read from the Windows registry. Since the + * application needs to honor the application level theme, this API reads the + * Application level theme setting. + *
+ * + * @returntrue if the current OS theme has a dark appearance, else
+ * returns false.
+ *
+ * @since 3.112
+ */
+public static boolean isSystemDarkTheme () {
+ boolean isDarkTheme = false;
+ /*
+ * Win10 onwards we can read the Dark Theme from the OS registry.
+ */
+ if (OS.WIN32_VERSION >= OS.VERSION (10, 0)) {
+ try {
+ int result = OS.readRegistryDword(OS.HKEY_CURRENT_USER,
+ "Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", "AppsUseLightTheme");
+ isDarkTheme = (result == 0);
+ } catch (Exception e) {
+ // Registry entry not found
+ }
+ }
+ return isDarkTheme;
+}
+
+int getLastEventTime () {
+ return OS.GetMessageTime ();
+}
+
+MenuItem getMenuItem (int id) {
+ if (items == null) return null;
+ id = id - ID_START;
+ if (0 <= id && id < items.length) return items [id];
+ return null;
+}
+
+int getMessageCount () {
+ /*
+ * On Windows10 (update 18272), an NPE is seen in below code which leads to a
+ * possible crash, adding a null check for synchronizer instance. For more
+ * details refer bug 540762
+ */
+ if (synchronizer != null) return synchronizer.getMessageCount ();
+ return 0;
+}
+
+
+Shell getModalShell () {
+ if (modalShells == null) return null;
+ int index = modalShells.length;
+ while (--index >= 0) {
+ Shell shell = modalShells [index];
+ if (shell != null) return shell;
+ }
+ return null;
+}
+
+Dialog getModalDialog () {
+ return modalDialog;
+}
+
+Monitor getMonitor (long hmonitor) {
+ MONITORINFO lpmi = new MONITORINFO ();
+ lpmi.cbSize = MONITORINFO.sizeof;
+ OS.GetMonitorInfo (hmonitor, lpmi);
+ Monitor monitor = new Monitor ();
+ monitor.handle = hmonitor;
+ Rectangle boundsInPixels = new Rectangle (lpmi.rcMonitor_left, lpmi.rcMonitor_top, lpmi.rcMonitor_right - lpmi.rcMonitor_left,lpmi.rcMonitor_bottom - lpmi.rcMonitor_top);
+ monitor.setBounds (DPIUtil.autoScaleDown (boundsInPixels));
+ Rectangle clientAreaInPixels = new Rectangle (lpmi.rcWork_left, lpmi.rcWork_top, lpmi.rcWork_right - lpmi.rcWork_left, lpmi.rcWork_bottom - lpmi.rcWork_top);
+ monitor.setClientArea (DPIUtil.autoScaleDown (clientAreaInPixels));
+ if (OS.WIN32_VERSION >= OS.VERSION (6, 3)) {
+ int [] dpiX = new int[1];
+ int [] dpiY = new int[1];
+ int result = OS.GetDpiForMonitor (monitor.handle, OS.MDT_EFFECTIVE_DPI, dpiX, dpiY);
+ result = (result == OS.S_OK) ? DPIUtil.mapDPIToZoom (dpiX[0]) : 100;
+ /*
+ * Always return true monitor zoom value as fetched from native, else will lead
+ * to scaling issue on OS Win8.1 and above, for more details refer bug 537614.
+ */
+ monitor.zoom = result;
+ } else {
+ monitor.zoom = getDeviceZoom ();
+ }
+ return monitor;
+}
+
+/**
+ * Returns an array of monitors attached to the device.
+ *
+ * @return the array of monitors
+ *
+ * @since 3.0
+ */
+public Monitor [] getMonitors () {
+ checkDevice ();
+ monitors = new Monitor [4];
+ Callback callback = new Callback (this, "monitorEnumProc", 4); //$NON-NLS-1$
+ long lpfnEnum = callback.getAddress ();
+ if (lpfnEnum == 0) error (SWT.ERROR_NO_MORE_CALLBACKS);
+ OS.EnumDisplayMonitors (0, null, lpfnEnum, 0);
+ callback.dispose ();
+ Monitor [] result = new Monitor [monitorCount];
+ System.arraycopy (monitors, 0, result, 0, monitorCount);
+ monitors = null;
+ monitorCount = 0;
+ return result;
+}
+
+long getMsgProc (long code, long wParam, long lParam) {
+ if (embeddedHwnd == 0) {
+ long hInstance = OS.GetModuleHandle (null);
+ embeddedHwnd = OS.CreateWindowEx (0,
+ windowClass,
+ null,
+ OS.WS_OVERLAPPED,
+ 0, 0, 0, 0,
+ 0,
+ 0,
+ hInstance,
+ null);
+ embeddedCallback = new Callback (this, "embeddedProc", 4); //$NON-NLS-1$
+ embeddedProc = embeddedCallback.getAddress ();
+ if (embeddedProc == 0) error (SWT.ERROR_NO_MORE_CALLBACKS);
+ OS.SetWindowLongPtr (embeddedHwnd, OS.GWLP_WNDPROC, embeddedProc);
+ }
+ if (code >= 0 && (wParam & OS.PM_REMOVE) != 0) {
+ MSG msg = new MSG ();
+ OS.MoveMemory (msg, lParam, MSG.sizeof);
+ switch (msg.message) {
+ case OS.WM_KEYDOWN:
+ case OS.WM_KEYUP:
+ case OS.WM_SYSKEYDOWN:
+ case OS.WM_SYSKEYUP: {
+ Control control = findControl (msg.hwnd);
+ if (control != null) {
+ long hHeap = OS.GetProcessHeap ();
+ long keyMsg = OS.HeapAlloc (hHeap, OS.HEAP_ZERO_MEMORY, MSG.sizeof);
+ OS.MoveMemory (keyMsg, msg, MSG.sizeof);
+ OS.PostMessage (hwndMessage, SWT_KEYMSG, wParam, keyMsg);
+ switch ((int)msg.wParam) {
+ case OS.VK_SHIFT:
+ case OS.VK_MENU:
+ case OS.VK_CONTROL:
+ case OS.VK_CAPITAL:
+ case OS.VK_NUMLOCK:
+ case OS.VK_SCROLL:
+ break;
+ default:
+ msg.message = OS.WM_NULL;
+ OS.MoveMemory (lParam, msg, MSG.sizeof);
+ }
+ }
+ }
+ }
+ }
+ return OS.CallNextHookEx (msgHook, (int)code, wParam, lParam);
+}
+
+/**
+ * Returns the primary monitor for that device.
+ *
+ * @return the primary monitor
+ *
+ * @since 3.0
+ */
+public Monitor getPrimaryMonitor () {
+ checkDevice ();
+ long hmonitor = OS.MonitorFromWindow (0, OS.MONITOR_DEFAULTTOPRIMARY);
+ return getMonitor (hmonitor);
+}
+
+/**
+ * Returns a (possibly empty) array containing all shells which have
+ * not been disposed and have the receiver as their display.
+ *
+ * @return the receiver's shells
+ *
+ * @exception SWTException syncExec
+ * or null if no such runnable is currently being invoked by
+ * the user-interface thread.
+ * + * Note: If a runnable invoked by asyncExec is currently + * running, this method will return null. + *
+ * + * @return the receiver's sync-interface thread + * + * @exception SWTExceptionSWT. Any value other
+ * than one of the SWT color constants which is passed
+ * in will result in the color black. This color should
+ * not be free'd because it was allocated by the system,
+ * not the application.
+ *
+ * @param id the color constant
+ * @return the matching color
+ *
+ * @exception SWTException SWT. This cursor should
+ * not be free'd because it was allocated by the system,
+ * not the application. A value of null will
+ * be returned if the supplied constant is not an SWT cursor
+ * constant.
+ *
+ * @param id the SWT cursor constant
+ * @return the corresponding cursor or null
+ *
+ * @exception SWTException + * Typically, applications which want the default look + * should simply not set the font on the widgets they + * create. Widgets are always created with the correct + * default font for the class of user-interface component + * they represent. + *
+ * + * @return a font + * + * @exception SWTExceptionSWT. This image should
+ * not be free'd because it was allocated by the system,
+ * not the application. A value of null will
+ * be returned either if the supplied constant is not an
+ * SWT icon constant or if the platform does not define an
+ * image that corresponds to the constant.
+ *
+ * @param id the SWT icon constant
+ * @return the corresponding image or null
+ *
+ * @exception SWTException null on platforms where no menu is provided for the application.
+ *
+ * @return the system menu, or null
+ *
+ * @exception SWTException null
+ *
+ * @exception SWTException null
+ *
+ * @exception SWTException true if a touch-aware input device is detected, or false otherwise
+ *
+ * @exception SWTException
+ * IMPORTANT: This method is not part of the public
+ * API for Display. It is marked public only so that it
+ * can be shared within the packages provided by SWT. It is not
+ * available on all platforms, and should never be called from
+ * application code.
+ *
+ * This method is called after create.
+ *
Display. It is marked public only so that it
+ * can be shared within the packages provided by SWT. It is not
+ * available on all platforms, and should never be called from
+ * application code.
+ *
+ *
+ * @param hDC the platform specific GC handle
+ * @param data the platform specific GC data
+ *
+ * @noreference This method is not intended to be referenced by clients.
+ */
+@Override
+public void internal_dispose_GC (long hDC, GCData data) {
+ OS.ReleaseDC (0, hDC);
+}
+
+boolean isXMouseActive () {
+ /*
+ * NOTE: X-Mouse is active when bit 1 of the UserPreferencesMask is set.
+ */
+ boolean xMouseActive = false;
+ try {
+ int result = OS.readRegistryDword(OS.HKEY_CURRENT_USER, "Control Panel\\Desktop", "UserPreferencesMask");
+ xMouseActive = (result & 0x01) != 0;
+ } catch (Exception e) {
+ // Registry entry not found
+ }
+ return xMouseActive;
+}
+
+boolean isValidThread () {
+ return thread == Thread.currentThread ();
+}
+
+/**
+ * Maps a point from one coordinate system to another.
+ * When the control is null, coordinates are mapped to
+ * the display.
+ * + * NOTE: On right-to-left platforms where the coordinate + * systems are mirrored, special care needs to be taken + * when mapping coordinates from one control to another + * to ensure the result is correctly mirrored. + * + * Mapping a point that is the origin of a rectangle and + * then adding the width and height is not equivalent to + * mapping the rectangle. When one control is mirrored + * and the other is not, adding the width and height to a + * point that was mapped causes the rectangle to extend + * in the wrong direction. Mapping the entire rectangle + * instead of just one point causes both the origin and + * the corner of the rectangle to be mapped. + *
+ * + * @param from the sourceControl or null
+ * @param to the destination Control or null
+ * @param point to be mapped
+ * @return point with mapped coordinates
+ *
+ * @exception IllegalArgumentException + * NOTE: On right-to-left platforms where the coordinate + * systems are mirrored, special care needs to be taken + * when mapping coordinates from one control to another + * to ensure the result is correctly mirrored. + * + * Mapping a point that is the origin of a rectangle and + * then adding the width and height is not equivalent to + * mapping the rectangle. When one control is mirrored + * and the other is not, adding the width and height to a + * point that was mapped causes the rectangle to extend + * in the wrong direction. Mapping the entire rectangle + * instead of just one point causes both the origin and + * the corner of the rectangle to be mapped. + *
+ * + * @param from the sourceControl or null
+ * @param to the destination Control or null
+ * @param x coordinates to be mapped
+ * @param y coordinates to be mapped
+ * @return point with mapped coordinates
+ *
+ * @exception IllegalArgumentException + * NOTE: On right-to-left platforms where the coordinate + * systems are mirrored, special care needs to be taken + * when mapping coordinates from one control to another + * to ensure the result is correctly mirrored. + * + * Mapping a point that is the origin of a rectangle and + * then adding the width and height is not equivalent to + * mapping the rectangle. When one control is mirrored + * and the other is not, adding the width and height to a + * point that was mapped causes the rectangle to extend + * in the wrong direction. Mapping the entire rectangle + * instead of just one point causes both the origin and + * the corner of the rectangle to be mapped. + *
+ * + * @param from the sourceControl or null
+ * @param to the destination Control or null
+ * @param rectangle to be mapped
+ * @return rectangle with mapped coordinates
+ *
+ * @exception IllegalArgumentException + * NOTE: On right-to-left platforms where the coordinate + * systems are mirrored, special care needs to be taken + * when mapping coordinates from one control to another + * to ensure the result is correctly mirrored. + * + * Mapping a point that is the origin of a rectangle and + * then adding the width and height is not equivalent to + * mapping the rectangle. When one control is mirrored + * and the other is not, adding the width and height to a + * point that was mapped causes the rectangle to extend + * in the wrong direction. Mapping the entire rectangle + * instead of just one point causes both the origin and + * the corner of the rectangle to be mapped. + *
+ * + * @param from the sourceControl or null
+ * @param to the destination Control or null
+ * @param x coordinates to be mapped
+ * @param y coordinates to be mapped
+ * @param width coordinates to be mapped
+ * @param height coordinates to be mapped
+ * @return rectangle with mapped coordinates
+ *
+ * @exception IllegalArgumentException post is used to generate low level keyboard
+ * and mouse events. The intent is to enable automated UI
+ * testing by simulating the input from the user. Most
+ * SWT applications should never need to call this method.
+ * + * Note that this operation can fail when the operating system + * fails to generate the event for any reason. For example, + * this can happen when there is no such key or mouse button + * or when the system event queue is full. + *
+ *+ * Event Types: + *
KeyDown, KeyUp + *
The following fields in the Event apply:
+ *
Either one of:
+ *SWTOptional (on some platforms):
+ *SWT
+ * MouseDown, MouseUp
+ *The following fields in the Event apply:
+ *
MouseMove
+ *The following fields in the Event apply:
+ *
MouseWheel
+ *The following fields in the Event apply:
true
+ * if there is potentially more work to do, or false
+ * if the caller can sleep until another event is placed on
+ * the event queue.
+ *
+ * In addition to checking the system event queue, this method also
+ * checks if any inter-thread messages (created by syncExec()
+ * or asyncExec()) are waiting to be processed, and if
+ * so handles them before returning.
+ *
false if the caller can sleep upon return from this method
+ *
+ * @exception SWTException true when sent the message
+ * isDisposed().
+ *
+ * When a device is destroyed, resources that were acquired
+ * on behalf of the programmer need to be returned to the
+ * operating system. For example, if the device allocated a
+ * font to be used as the system font, this font would be
+ * freed in release. Also,to assist the garbage
+ * collector and minimize the amount of memory that is not
+ * reclaimed when the programmer keeps a reference to a
+ * disposed device, all fields except the handle are zero'd.
+ * The handle is needed by destroy.
+ *
destroy.
+ *
+ * @see Device#dispose
+ * @see #destroy
+ */
+@Override
+protected void release () {
+ sendEvent (SWT.Dispose, new Event ());
+ Shell [] shells = getShells ();
+ for (int i=0; iSWT.
+ *
+ * @param eventType the type of event to listen for
+ * @param listener the listener which should no longer be notified
+ *
+ * @exception IllegalArgumentException
+ * Applications may have associated arbitrary objects with the
+ * receiver in this fashion. If the objects stored in the
+ * properties need to be notified when the display is disposed
+ * of, it is the application's responsibility provide a
+ * disposeExec() handler which does so.
+ *
+ * Applications may put arbitrary objects in this field. If
+ * the object stored in the display specific data needs to
+ * be notified when the display is disposed of, it is the
+ * application's responsibility provide a
+ * disposeExec() handler which does so.
+ *
+ * The application name can be used in several ways, + * depending on the platform and tools being used. + * Accessibility tools could ask for the application + * name. On Windows, if the application name is set + * to any value other than "SWT" (case insensitive), + * it is used to set the application user model ID + * which is used by the OS for taskbar grouping. + * @see AppUserModelID (Windows) + *
+ * Specifying null for the name clears it.
+ *
null
+ */
+public static void setAppName (String name) {
+ APP_NAME = name;
+}
+
+/**
+ * Sets the application version to the argument.
+ *
+ * @param version the new app version
+ *
+ * @since 3.6
+ */
+public static void setAppVersion (String version) {
+ APP_VERSION = version;
+}
+
+void setModalDialog (Dialog modalDailog) {
+ this.modalDialog = modalDailog;
+ Shell [] shells = getShells ();
+ for (int i=0; i
+ * The default SWT error handling policy is to rethrow exceptions.
+ *
+ * @param runtimeExceptionHandler new exception handler to be registered.
+ * @since 3.106
+ */
+public final void setRuntimeExceptionHandler (Consumer
+ * The default SWT error handling policy is to rethrow exceptions.
+ *
+ * @param errorHandler new error handler to be registered.
+ * @since 3.106
+ */
+public final void setErrorHandler (Consumer
+ * 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.
+ *
+ * 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.
+ * null.
+ * @since 3.106
+ */
+public final Consumernull.
+ * @since 3.106
+ */
+public final Consumertrue if an event requiring dispatching was placed on the queue.
+ *
+ * @exception SWTException
+ *
+ *
+ * @see #wake
+ */
+public boolean sleep () {
+ checkDevice ();
+ if (getMessageCount () != 0) return true;
+ sendPreExternalEventDispatchEvent ();
+ boolean result = OS.WaitMessage ();
+ sendPostExternalEventDispatchEvent ();
+ return result;
+}
+
+/**
+ * Causes the run() method of the runnable to
+ * be invoked by the user-interface thread at the next
+ * reasonable opportunity. The thread which calls this method
+ * is suspended until the runnable completes. Specifying null
+ * as the runnable simply wakes the user-interface thread.
+ * null
+ *
+ * @exception SWTException
+ *
+ *
+ * @see #asyncExec
+ */
+public void syncExec (Runnable runnable) {
+ Synchronizer synchronizer;
+ synchronized (Device.class) {
+ if (isDisposed ()) error (SWT.ERROR_DEVICE_DISPOSED);
+ synchronizer = this.synchronizer;
+ }
+ synchronizer.syncExec (runnable);
+}
+
+/**
+ * Causes the run() method of the runnable to
+ * be invoked by the user-interface thread after the specified
+ * number of milliseconds have elapsed. If milliseconds is less
+ * than zero, the runnable is not executed.
+ *
+ *
+ * @exception SWTException
+ *
+ *
+ * @see #asyncExec
+ */
+public void timerExec (int milliseconds, Runnable runnable) {
+ checkDevice ();
+ if (runnable == null) error (SWT.ERROR_NULL_ARGUMENT);
+ if (timerList == null) timerList = new Runnable [4];
+ if (timerIds == null) timerIds = new long [4];
+ int index = 0;
+ while (index < timerList.length) {
+ if (timerList [index] == runnable) break;
+ index++;
+ }
+ long timerId = 0;
+ if (index != timerList.length) {
+ timerId = timerIds [index];
+ if (milliseconds < 0) {
+ OS.KillTimer (hwndMessage, timerId);
+ timerList [index] = null;
+ timerIds [index] = 0;
+ return;
+ }
+ } else {
+ if (milliseconds < 0) return;
+ index = 0;
+ while (index < timerList.length) {
+ if (timerList [index] == null) break;
+ index++;
+ }
+ timerId = nextTimerId++;
+ if (index == timerList.length) {
+ Runnable [] newTimerList = new Runnable [timerList.length + 4];
+ System.arraycopy (timerList, 0, newTimerList, 0, timerList.length);
+ timerList = newTimerList;
+ long [] newTimerIds = new long [timerIds.length + 4];
+ System.arraycopy (timerIds, 0, newTimerIds, 0, timerIds.length);
+ timerIds = newTimerIds;
+ }
+ }
+ long newTimerID = OS.SetTimer (hwndMessage, timerId, milliseconds, 0);
+ if (newTimerID != 0) {
+ timerList [index] = runnable;
+ timerIds [index] = newTimerID;
+ }
+}
+
+boolean translateAccelerator (MSG msg, Control control) {
+ accelKeyHit = true;
+ boolean result = control.translateAccelerator (msg);
+ accelKeyHit = false;
+ return result;
+}
+
+static int translateKey (int key) {
+ for (int i=0; i
+ *
+ *
+ * @see #sleep
+ */
+public void wake () {
+ synchronized (Device.class) {
+ if (isDisposed ()) error (SWT.ERROR_DEVICE_DISPOSED);
+ if (thread == Thread.currentThread ()) return;
+ wakeThread ();
+ }
+}
+
+void wakeThread () {
+ OS.PostThreadMessage (threadId, OS.WM_NULL, 0, 0);
+}
+
+long windowProc (long hwnd, long msg, long wParam, long lParam) {
+ if (lastControl != null && lastHwnd == hwnd) {
+ return lastControl.windowProc (hwnd, (int)msg, wParam, lParam);
+ }
+ int index = (int)OS.GetProp (hwnd, SWT_OBJECT_INDEX) - 1;
+ if (0 <= index && index < controlTable.length) {
+ Control control = controlTable [index];
+ if (control != null) {
+ lastHwnd = hwnd;
+ lastControl = control;
+ return control.windowProc (hwnd, (int)msg, wParam, lParam);
+ }
+ }
+ return OS.DefWindowProc (hwnd, (int)msg, wParam, lParam);
+}
+
+int textWidth (String text, long handle) {
+ long oldFont = 0;
+ RECT rect = new RECT ();
+ long hDC = OS.GetDC (handle);
+ long newFont = OS.SendMessage (handle, OS.WM_GETFONT, 0, 0);
+ if (newFont != 0) oldFont = OS.SelectObject (hDC, newFont);
+ int flags = OS.DT_CALCRECT | OS.DT_SINGLELINE | OS.DT_NOPREFIX;
+ char [] buffer = text.toCharArray ();
+ OS.DrawText (hDC, buffer, buffer.length, rect, flags);
+ if (newFont != 0) OS.SelectObject (hDC, oldFont);
+ OS.ReleaseDC (handle, hDC);
+ return (rect.right - rect.left);
+}
+
+String wrapText (String text, long handle, int width) {
+ String Lf = "\r\n"; //$NON-NLS-1$
+ text = withCrLf (text);
+ int length = text.length ();
+ if (width <= 0 || length == 0 || length == 1) return text;
+ StringBuilder result = new StringBuilder ();
+ int lineStart = 0, lineEnd = 0;
+ while (lineStart < length) {
+ lineEnd = text.indexOf (Lf, lineStart);
+ boolean noLf = lineEnd == -1;
+ if (noLf) lineEnd = length;
+ int nextStart = lineEnd + Lf.length ();
+ while (lineEnd > lineStart + 1 && Character.isWhitespace (text.charAt (lineEnd - 1))) {
+ lineEnd--;
+ }
+ int wordStart = lineStart, wordEnd = lineStart;
+ int i = lineStart;
+ while (i < lineEnd) {
+ int lastStart = wordStart, lastEnd = wordEnd;
+ wordStart = i;
+ while (i < lineEnd && !Character.isWhitespace (text.charAt (i))) {
+ i++;
+ }
+ wordEnd = i - 1;
+ String line = text.substring (lineStart, wordEnd + 1);
+ int lineWidth = textWidth (line, handle);
+ while (i < lineEnd && Character.isWhitespace (text.charAt (i))) {
+ i++;
+ }
+ if (lineWidth > width) {
+ if (lastStart == wordStart) {
+ while (wordStart < wordEnd) {
+ line = text.substring (lineStart, wordStart + 1);
+ lineWidth = textWidth (line, handle);
+ if (lineWidth >= width) break;
+ wordStart++;
+ }
+ if (wordStart == lastStart) wordStart++;
+ lastEnd = wordStart - 1;
+ }
+ line = text.substring (lineStart, lastEnd + 1);
+ result.append (line); result.append (Lf);
+ i = wordStart; lineStart = wordStart; wordEnd = wordStart;
+ }
+ }
+ if (lineStart < lineEnd) {
+ result.append (text.substring (lineStart, lineEnd));
+ }
+ if (!noLf) {
+ result.append (Lf);
+ }
+ lineStart = nextStart;
+ }
+ return result.toString ();
+}
+
+static String withCrLf (String string) {
+
+ /* If the string is empty, return the string. */
+ int length = string.length ();
+ if (length == 0) return string;
+
+ /*
+ * Check for an LF or CR/LF and assume the rest of
+ * the string is formated that way. This will not
+ * work if the string contains mixed delimiters.
+ */
+ int i = string.indexOf ('\n', 0);
+ if (i == -1) return string;
+ if (i > 0 && string.charAt (i - 1) == '\r') {
+ return string;
+ }
+
+ /*
+ * The string is formatted with LF. Compute the
+ * number of lines and the size of the buffer
+ * needed to hold the result
+ */
+ i++;
+ int count = 1;
+ while (i < length) {
+ if ((i = string.indexOf ('\n', i)) == -1) break;
+ count++; i++;
+ }
+ count += length;
+
+ /* Create a new string with the CR/LF line terminator. */
+ i = 0;
+ StringBuilder result = new StringBuilder (count);
+ while (i < length) {
+ int j = string.indexOf ('\n', i);
+ if (j == -1) j = length;
+ result.append (string.substring (i, j));
+ if ((i = j) < length) {
+ result.append ("\r\n"); //$NON-NLS-1$
+ i++;
+ }
+ }
+ return result.toString ();
+}
+
+static char [] withCrLf (char [] string) {
+ /* If the string is empty, return the string. */
+ int length = string.length;
+ if (length == 0) return string;
+
+ /*
+ * Check for an LF or CR/LF and assume the rest of
+ * the string is formated that way. This will not
+ * work if the string contains mixed delimiters.
+ * Also, compute the number of lines.
+ */
+ int count = 0;
+ for (int i = 0; i < string.length; i++) {
+ if (string [i] == '\n') {
+ count++;
+ if (count == 1 && i > 0 && string [i - 1] == '\r') return string;
+ }
+ }
+ if (count == 0) return string;
+
+ /*
+ * The string is formatted with LF.
+ */
+ count += length;
+
+ /* Create a new string with the CR/LF line terminator. */
+ char [] result = new char [count];
+ for (int i = 0, j = 0; i < length && j < count; i++) {
+ if (string [i] == '\n') {
+ result [j++] = '\r';
+ }
+ result [j++] = string [i];
+ }
+
+ return result;
+}
+
+}