Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2011, 2012 IBM Corporation, Gerhardt Informatics Kft. 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 * Gerhardt Informatics Kft. - GEFGWT port *******************************************************************************/ package org.eclipse.swt.widgets; import org.eclipse.swt.SWT; import org.eclipse.swt.SWTError; import org.eclipse.swt.SWTException; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Cursor; import org.eclipse.swt.graphics.Device; import org.eclipse.swt.graphics.DeviceData; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.GCData; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.graphics.Resource; import org.eclipse.swt.internal.Callback; import org.eclipse.swt.internal.gwt.GdkColor; import org.eclipse.swt.internal.gwt.GdkRectangle; import org.eclipse.swt.internal.gwt.XExposeEvent; import org.eclipse.swt.internal.gwt.XVisibilityEvent; import com.google.gwt.user.client.Timer; /** * 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, OpenDocument, Settings, Skin</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> * @noextend This class is not intended to be subclassed by clients. */ public class Display extends Device { /* Events Dispatching and Callback */ int gdkEventCount; long /* int */[] gdkEvents; Widget[] gdkEventWidgets; int[] dispatchEvents; Event[] eventQueue; long /* int */ fds; int allocated_nfds; boolean wake; int[] max_priority = new int[1], timeout = new int[1]; Callback eventCallback, filterCallback; long /* int */ eventProc, filterProc, windowProc2, windowProc3, windowProc4, windowProc5; Callback windowCallback2, windowCallback3, windowCallback4, windowCallback5; EventTable eventTable, filterTable; static String APP_NAME = "SWT"; //$NON-NLS-1$ static String APP_VERSION = ""; //$NON-NLS-1$ static final String DISPATCH_EVENT_KEY = "org.eclipse.swt.internal.gtk.dispatchEvent"; //$NON-NLS-1$ static final String ADD_WIDGET_KEY = "org.eclipse.swt.internal.addWidget"; //$NON-NLS-1$ long /* int */[] closures; int[] signalIds; long /* int */ shellMapProcClosure; /* Widget Table */ int[] indexTable; int freeSlot; long /* int */ lastHandle; Widget lastWidget; Widget[] widgetTable; final static int GROW_SIZE = 1024; /* Modality */ Shell[] modalShells; Dialog modalDialog; static final String GET_MODAL_DIALOG = "org.eclipse.swt.internal.gtk.getModalDialog"; //$NON-NLS-1$ static final String SET_MODAL_DIALOG = "org.eclipse.swt.internal.gtk.setModalDialog"; //$NON-NLS-1$ /* Focus */ int focusEvent; Control focusControl; Shell activeShell; boolean activePending; boolean ignoreActivate, ignoreFocus; /* Input method resources */ Control imControl; long /* int */ preeditWindow, preeditLabel; /* Sync/Async Widget Communication */ Synchronizer synchronizer = new Synchronizer(this); /** * TODO Thread thread; */ /* Display Shutdown */ Runnable[] disposeList; /* Deferred Layout list */ Composite[] layoutDeferred; int layoutDeferredCount; /* System Tray */ Tray tray; TrayItem currentTrayItem; /* Timers */ int[] timerIds; Runnable[] timerList; Callback timerCallback; long /* int */ timerProc; Callback windowTimerCallback; long /* int */ windowTimerProc; /* Caret */ Caret currentCaret; Callback caretCallback; int caretId; long /* int */ caretProc; /* Mnemonics */ Control mnemonicControl; /* Mouse hover */ int mouseHoverId; long /* int */ mouseHoverHandle, mouseHoverProc; Callback mouseHoverCallback; /* Menu position callback */ long /* int */ menuPositionProc; Callback menuPositionCallback; /* Tooltip size allocate callback */ long /* int */ sizeAllocateProc; Callback sizeAllocateCallback; long /* int */ sizeRequestProc; Callback sizeRequestCallback; /* Shell map callback */ long /* int */ shellMapProc; Callback shellMapCallback; /* Idle proc callback */ long /* int */ idleProc; int idleHandle; Callback idleCallback; static final String ADD_IDLE_PROC_KEY = "org.eclipse.swt.internal.gtk.addIdleProc"; //$NON-NLS-1$ static final String REMOVE_IDLE_PROC_KEY = "org.eclipse.swt.internal.gtk.removeIdleProc"; //$NON-NLS-1$ Object idleLock = new Object(); boolean idleNeeded; /* GtkTreeView callbacks */ int[] treeSelection; int treeSelectionLength; long /* int */ treeSelectionProc; Callback treeSelectionCallback; long /* int */ cellDataProc; Callback cellDataCallback; /* Set direction callback */ long /* int */ setDirectionProc; Callback setDirectionCallback; static final String GET_DIRECTION_PROC_KEY = "org.eclipse.swt.internal.gtk.getDirectionProc"; //$NON-NLS-1$ /* Set emissionProc callback */ long /* int */ emissionProc; Callback emissionProcCallback; static final String GET_EMISSION_PROC_KEY = "org.eclipse.swt.internal.gtk.getEmissionProc"; //$NON-NLS-1$ /* Get all children callback */ long /* int */ allChildrenProc, allChildren; Callback allChildrenCallback; /* Settings callbacks */ long /* int */ signalProc; Callback signalCallback; long /* int */ shellHandle; boolean settingsChanged, runSettings; static final int STYLE_SET = 1; static final int PROPERTY_NOTIFY = 2; /* Entry focus behaviour */ boolean entrySelectOnFocus; /* Enter/Exit events */ Control currentControl; /* Flush exposes */ long /* int */ checkIfEventProc; Callback checkIfEventCallback; long /* int */ flushWindow; boolean flushAll; GdkRectangle flushRect = new GdkRectangle(); XExposeEvent exposeEvent = new XExposeEvent(); XVisibilityEvent visibilityEvent = new XVisibilityEvent(); long /* int */[] flushData = new long /* int */[1]; /* System Resources */ Font systemFont; Image errorImage, infoImage, questionImage, warningImage; Cursor[] cursors = new Cursor[SWT.CURSOR_HAND + 1]; Resource[] resources; static final int RESOURCE_SIZE = 1 + 4 + SWT.CURSOR_HAND + 1; /* Colors */ GdkColor COLOR_WIDGET_DARK_SHADOW, COLOR_WIDGET_NORMAL_SHADOW, COLOR_WIDGET_LIGHT_SHADOW; GdkColor COLOR_WIDGET_HIGHLIGHT_SHADOW, COLOR_WIDGET_BACKGROUND, COLOR_WIDGET_FOREGROUND, COLOR_WIDGET_BORDER; GdkColor COLOR_LIST_FOREGROUND, COLOR_LIST_BACKGROUND, COLOR_LIST_SELECTION, COLOR_LIST_SELECTION_TEXT; GdkColor COLOR_INFO_BACKGROUND, COLOR_INFO_FOREGROUND; GdkColor COLOR_TITLE_FOREGROUND, COLOR_TITLE_BACKGROUND, COLOR_TITLE_BACKGROUND_GRADIENT; GdkColor COLOR_TITLE_INACTIVE_FOREGROUND, COLOR_TITLE_INACTIVE_BACKGROUND, COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT; /* Popup Menus */ Menu[] popups; /* Click count */ int clickCount = 1; /* Entry inner border */ static final int INNER_BORDER = 2; /* Timestamp of the Last Received Events */ int lastEventTime, lastUserEventTime; /* Pango layout constructor */ long /* int */ pangoLayoutNewProc; /* Custom Resize */ double resizeLocationX, resizeLocationY; int resizeBoundsX, resizeBoundsY, resizeBoundsWidth, resizeBoundsHeight; int resizeMode; /* Fixed Subclass */ static long /* int */ fixed_type; static long /* int */ fixed_info_ptr; static Callback fixedClassInitCallback, fixedMapCallback, fixedSizeAllocateCallback; static long /* int */ fixedClassInitProc, fixedMapProc, fixedSizeAllocateProc, oldFixedSizeAllocateProc; /* Renderer Subclass */ static long /* int */ text_renderer_type, pixbuf_renderer_type, toggle_renderer_type; static long /* int */ text_renderer_info_ptr, pixbuf_renderer_info_ptr, toggle_renderer_info_ptr; static Callback rendererClassInitCallback, rendererRenderCallback, rendererGetSizeCallback; static long /* int */ rendererClassInitProc, rendererRenderProc, rendererGetSizeProc; /* Multiple Displays. */ static Display Default; static Display[] Displays = new Display[4]; /* Skinning support */ Widget[] skinList = new Widget[GROW_SIZE]; int skinCount; /* Package name */ static final String PACKAGE_PREFIX = "org.eclipse.swt.widgets."; //$NON-NLS-1$ /* GTK Version */ static final int MAJOR = 2; static final int MINOR = 2; static final int MICRO = 0; /* Display Data */ Object data; String[] keys; Object[] values; /* Initial Guesses for Shell Trimmings. */ int borderTrimWidth = 4, borderTrimHeight = 4; int resizeTrimWidth = 6, resizeTrimHeight = 6; int titleBorderTrimWidth = 5, titleBorderTrimHeight = 28; int titleResizeTrimWidth = 6, titleResizeTrimHeight = 29; int titleTrimWidth = 0, titleTrimHeight = 23; boolean ignoreTrim; /* Window Manager */ String windowManager; /* * 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> 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 subclass</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); } /** * 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); } void addLayoutDeferred(Composite comp) { if (layoutDeferred == null) layoutDeferred = new Composite[64]; if (layoutDeferredCount == layoutDeferred.length) { Composite[] temp = new Composite[layoutDeferred.length + 64]; System.arraycopy(layoutDeferred, 0, temp, 0, layoutDeferred.length); layoutDeferred = temp; } layoutDeferred[layoutDeferredCount++] = comp; } /** * 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); } void addPopup(Menu menu) { if (popups == null) popups = new Menu[4]; int length = popups.length; for (int i = 0; i < length; i++) { if (popups[i] == menu) return; } int index = 0; while (index < length) { if (popups[index] == null) break; index++; } if (index == length) { Menu[] newPopups = new Menu[length + 4]; System.arraycopy(popups, 0, newPopups, 0, length); popups = newPopups; } popups[index] = menu; } void addSkinnableWidget(Widget widget) { if (skinCount >= skinList.length) { Widget[] newSkinWidgets = new Widget[skinList.length + GROW_SIZE]; System.arraycopy(skinList, 0, newSkinWidgets, 0, skinList.length); skinList = newSkinWidgets; } skinList[skinCount++] = widget; } void addWidget(long /* int */ handle, Widget 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) { timerExec(1, 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() { } protected void checkDevice() { } /** * Checks that this class can be subclassed. * <p> * IMPORTANT: See the comment in <code>Widget.checkSubclass()</code>. * </p> * * @exception SWTException * <ul> * <li>ERROR_INVALID_SUBCLASS - if this class is not an * allowed subclass</li> * </ul> * * @see Widget#checkSubclass */ protected void checkSubclass() { if (!isValidClass(getClass())) error(SWT.ERROR_INVALID_SUBCLASS); } /** * Requests that the connection between SWT and the underlying operating * system be closed. * * @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 Device#dispose * * @since 2.0 */ public void close() { checkDevice(); Event event = new Event(); sendEvent(SWT.Close, event); if (event.doit) dispose(); } /** * Creates the device in the operating system. If the device does not have a * handle, this method may do nothing depending on the device. * <p> * This method is called before <code>init</code>. * </p> * * @param data * the DeviceData which describes the receiver * * @see #init */ protected void create(DeviceData data) { // checkSubclass(); // checkDisplay(thread = Thread.currentThread(), false); // createDisplay(data); // register(this); // if (Default == null) // Default = this; } Image createImage(String name) { return null; } static void deregister(Display display) { synchronized (Device.class) { for (int i = 0; i < Displays.length; i++) { if (display == Displays[i]) Displays[i] = null; } } } /** * Destroys the device in the operating system and releases the device's * handle. If the device does not have a handle, this method may do nothing * depending on the device. * <p> * This method is called after <code>release</code>. * </p> * * @see Device#dispose * @see #release */ protected void destroy() { if (this == Default) Default = null; deregister(this); destroyDisplay(); } void destroyDisplay() { } /** * Returns the display which the given thread is the user-interface thread * for, or null if the given thread is not a user-interface thread for any * display. Specifying <code>null</code> as the thread will return * <code>null</code> for the display. * * @param thread * the user-interface thread * @return the display for the given thread */ public static Display findDisplay(/* Thread thread */) { return null; } /** * Causes the <code>run()</code> method of the runnable to be invoked by the * user-interface thread just before the receiver is disposed. Specifying a * <code>null</code> runnable is ignored. * * @param runnable * code to run at dispose time. * * @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 disposeExec(Runnable runnable) { checkDevice(); if (disposeList == null) disposeList = new Runnable[4]; for (int i = 0; i < disposeList.length; i++) { if (disposeList[i] == null) { disposeList[i] = runnable; return; } } Runnable[] newDisposeList = new Runnable[disposeList.length + 4]; System.arraycopy(disposeList, 0, newDisposeList, 0, disposeList.length); newDisposeList[disposeList.length] = runnable; disposeList = newDisposeList; } /** * Does whatever display specific cleanup is required, and then uses the * code in <code>SWTError.error</code> to handle the error. * * @param code * the descriptive error code * * @see SWTError#error */ void error(int code) { SWT.error(code); } /** * Given the operating system handle for a widget, returns the instance of * the <code>Widget</code> subclass which represents it in the currently * running application, if such exists, or null if no matching widget can be * found. * <p> * <b>IMPORTANT:</b> This method should not be called from application code. * The arguments are platform-specific. * </p> * * @param handle * the handle for the widget * @return the SWT widget that the handle represents * * @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> * * @noreference This method is not intended to be referenced by clients. */ public Widget findWidget(long /* int */ handle) { checkDevice(); return getWidget(handle); } /** * Given the operating system handle for a widget, and widget-specific id, * returns the instance of the <code>Widget</code> subclass which represents * the handle/id pair in the currently running application, if such exists, * or null if no matching widget can be found. * <p> * <b>IMPORTANT:</b> This method should not be called from application code. * The arguments are platform-specific. * </p> * * @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 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> * * @noreference This method is not intended to be referenced by clients. * * @since 3.1 */ public Widget findWidget(long /* int */ handle, long /* int */ id) { checkDevice(); return null; } /** * Given a widget and a widget-specific id, returns the instance of the * <code>Widget</code> 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 * <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> * * @since 3.3 */ public Widget findWidget(Widget widget, long /* int */ id) { checkDevice(); return null; } /** * Returns the currently active <code>Shell</code>, or null if no shell * belonging to the currently running application is active. * * @return the active shell or null * * @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 Shell getActiveShell() { checkDevice(); return activeShell; } /** * Returns a rectangle describing the receiver's size and location. Note * that on multi-monitor systems the origin can be negative. * * @return the bounding rectangle * * @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 Rectangle getBounds() { return null; } /** * Returns the display which the currently running thread is the * user-interface thread for, or null if the currently running thread is not * a user-interface thread for any display. * * @return the current display */ public static Display getCurrent() { // return findDisplay(Thread.currentThread()); return getDefault(); } int getCaretBlinkTime() { return 0; } /** * Returns the control which the on-screen pointer is currently over top of, * or null if it is not currently over one of the controls built by the * currently running application. * * @return the control under the cursor or <code>null</code> * * @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 Control getCursorControl() { return null; } boolean filterEvent(Event event) { if (filterTable != null) filterTable.sendEvent(event); return false; } boolean filters(int eventType) { if (filterTable == null) return false; return filterTable.hooks(eventType); } /** * Returns the location of the on-screen pointer relative to the top left * corner of the screen. * * @return the cursor location * * @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 Point getCursorLocation() { return new Point(100, 100); } /** * Returns an array containing the recommended cursor sizes. * * @return the array of cursor sizes * * @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> * * @since 3.0 */ public Point[] getCursorSizes() { checkDevice(); return new Point[] { new Point(16, 16), new Point(32, 32) }; } /** * Returns the application defined property of the receiver with the * specified name, or null if it has not been set. * <p> * 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 <code>disposeExec()</code> handler which does so. * </p> * * @param key * the name of the property * @return the value of the property or null if it has not been set * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the key 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 #setData(String, Object) * @see #disposeExec(Runnable) */ public Object getData(String key) { return null; } /** * Returns the application defined, display specific data associated with * the receiver, or null if it has not been set. The * <em>display specific data</em> is a single, unnamed field that is stored * with every display. * <p> * 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 * <code>disposeExec()</code> handler which does so. * </p> * * @return the display specific data * * @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 #setData(Object) * @see #disposeExec(Runnable) */ public Object getData() { checkDevice(); return data; } /** * Returns the default display. One is created (making the thread that * invokes this method its user-interface thread) if it did not already * exist. * * @return the default display */ public static Display getDefault() { synchronized (Device.class) { if (Default == null) Default = new Display(); return Default; } } static boolean isValidClass(Class clazz) { String name = clazz.getName(); int index = name.lastIndexOf('.'); return name.substring(0, index + 1).equals(PACKAGE_PREFIX); } /** * Returns the single instance of the application menu bar, or * <code>null</code> if there is no application menu bar for the platform. * * @return the application menu bar, or <code>null</code> * * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * * @since 3.7 */ public Menu getMenuBar() { checkDevice(); return null; } /** * Returns the button dismissal alignment, one of <code>LEFT</code> or * <code>RIGHT</code>. 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 <code>LEFT</code>, * the button ordering should be OK/CANCEL. When button dismissal alignment * is <code>RIGHT</code>, the button ordering should be CANCEL/OK. * * @return the button dismissal order * * @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> * * @since 2.1 */ public int getDismissalAlignment() { return 0; } /** * Returns the longest duration, in milliseconds, between two mouse button * clicks that will be considered a <em>double click</em> by the underlying * operating system. * * @return the double click time * * @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 int getDoubleClickTime() { return 0; } /** * Returns the control which currently has keyboard focus, or null if * keyboard events are not currently going to any of the controls built by * the currently running application. * * @return the focus control or <code>null</code> * * @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 Control getFocusControl() { return null; } /** * Returns true when the high contrast mode is enabled. Otherwise, false is * returned. * <p> * Note: This operation is a hint and is not supported on platforms that do * not have this concept. * </p> * * @return the high contrast mode * * @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> * * @since 3.0 */ public boolean getHighContrast() { checkDevice(); return false; } public int getDepth() { return 0; } /** * Returns the maximum allowed depth of icons on this display, in bits per * pixel. On some platforms, this may be different than the actual depth of * the display. * * @return the maximum icon depth * * @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 Device#getDepth */ public int getIconDepth() { checkDevice(); return getDepth(); } /** * Returns an array containing the recommended icon sizes. * * @return the array of icon sizes * * @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 Decorations#setImages(Image[]) * * @since 3.0 */ public Point[] getIconSizes() { checkDevice(); return new Point[] { new Point(16, 16), new Point(32, 32) }; } int getLastEventTime() { return lastEventTime; } Dialog getModalDialog() { return modalDialog; } /** * Returns an array of monitors attached to the device. * * @return the array of monitors * * @since 3.0 */ public Monitor[] getMonitors() { return null; } /** * Returns the primary monitor for that device. * * @return the primary monitor * * @since 3.0 */ public Monitor getPrimaryMonitor() { checkDevice(); Monitor[] monitors = getMonitors(); return monitors[0]; } /** * 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 * <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 Shell[] getShells() { return null; } /** * Gets the synchronizer used by the display. * * @return the receiver's synchronizer * * @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> * * @since 3.4 */ public Synchronizer getSynchronizer() { checkDevice(); return synchronizer; } /** * Returns the thread that has invoked <code>syncExec</code> or null if no * such runnable is currently being invoked by the user-interface thread. * <p> * Note: If a runnable invoked by asyncExec is currently running, this * method will return null. * </p> * * @return the receiver's sync-interface thread * * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> */ /** * TODO public Thread getSyncThread() { synchronized (Device.class) { if * (isDisposed()) error(SWT.ERROR_DEVICE_DISPOSED); return * synchronizer.syncThread; } } */ /** * Returns the matching standard color for the given constant, which should * be one of the color constants specified in class <code>SWT</code>. 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 * <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 SWT */ public Color getSystemColor(int id) { checkDevice(); GdkColor gdkColor = null; switch (id) { case SWT.COLOR_INFO_FOREGROUND: gdkColor = COLOR_INFO_FOREGROUND; break; case SWT.COLOR_INFO_BACKGROUND: gdkColor = COLOR_INFO_BACKGROUND; break; case SWT.COLOR_TITLE_FOREGROUND: gdkColor = COLOR_TITLE_FOREGROUND; break; case SWT.COLOR_TITLE_BACKGROUND: gdkColor = COLOR_TITLE_BACKGROUND; break; case SWT.COLOR_TITLE_BACKGROUND_GRADIENT: gdkColor = COLOR_TITLE_BACKGROUND_GRADIENT; break; case SWT.COLOR_TITLE_INACTIVE_FOREGROUND: gdkColor = COLOR_TITLE_INACTIVE_FOREGROUND; break; case SWT.COLOR_TITLE_INACTIVE_BACKGROUND: gdkColor = COLOR_TITLE_INACTIVE_BACKGROUND; break; case SWT.COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT: gdkColor = COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT; break; case SWT.COLOR_WIDGET_DARK_SHADOW: gdkColor = COLOR_WIDGET_DARK_SHADOW; break; case SWT.COLOR_WIDGET_NORMAL_SHADOW: gdkColor = COLOR_WIDGET_NORMAL_SHADOW; break; case SWT.COLOR_WIDGET_LIGHT_SHADOW: gdkColor = COLOR_WIDGET_LIGHT_SHADOW; break; case SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW: gdkColor = COLOR_WIDGET_HIGHLIGHT_SHADOW; break; case SWT.COLOR_WIDGET_BACKGROUND: gdkColor = COLOR_WIDGET_BACKGROUND; break; case SWT.COLOR_WIDGET_FOREGROUND: gdkColor = COLOR_WIDGET_FOREGROUND; break; case SWT.COLOR_WIDGET_BORDER: gdkColor = COLOR_WIDGET_BORDER; break; case SWT.COLOR_LIST_FOREGROUND: gdkColor = COLOR_LIST_FOREGROUND; break; case SWT.COLOR_LIST_BACKGROUND: gdkColor = COLOR_LIST_BACKGROUND; break; case SWT.COLOR_LIST_SELECTION: gdkColor = COLOR_LIST_SELECTION; break; case SWT.COLOR_LIST_SELECTION_TEXT: gdkColor = COLOR_LIST_SELECTION_TEXT; break; default: return super.getSystemColor(id); } if (gdkColor == null) return super.getSystemColor(SWT.COLOR_BLACK); return Color.gtk_new(this, gdkColor); } /** * Returns the matching standard platform cursor for the given constant, * which should be one of the cursor constants specified in class * <code>SWT</code>. This cursor should not be free'd because it was * allocated by the system, not the application. A value of * <code>null</code> will be returned if the supplied constant is not an SWT * cursor constant. * * @param id * the SWT cursor constant * @return the corresponding cursor or <code>null</code> * * @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 SWT#CURSOR_ARROW * @see SWT#CURSOR_WAIT * @see SWT#CURSOR_CROSS * @see SWT#CURSOR_APPSTARTING * @see SWT#CURSOR_HELP * @see SWT#CURSOR_SIZEALL * @see SWT#CURSOR_SIZENESW * @see SWT#CURSOR_SIZENS * @see SWT#CURSOR_SIZENWSE * @see SWT#CURSOR_SIZEWE * @see SWT#CURSOR_SIZEN * @see SWT#CURSOR_SIZES * @see SWT#CURSOR_SIZEE * @see SWT#CURSOR_SIZEW * @see SWT#CURSOR_SIZENE * @see SWT#CURSOR_SIZESE * @see SWT#CURSOR_SIZESW * @see SWT#CURSOR_SIZENW * @see SWT#CURSOR_UPARROW * @see SWT#CURSOR_IBEAM * @see SWT#CURSOR_NO * @see SWT#CURSOR_HAND * * @since 3.0 */ public Cursor getSystemCursor(int id) { checkDevice(); if (!(0 <= id && id < cursors.length)) return null; if (cursors[id] == null) { cursors[id] = new Cursor(this, id); } return cursors[id]; } /** * Returns the matching standard platform image for the given constant, * which should be one of the icon constants specified in class * <code>SWT</code>. This image should not be free'd because it was * allocated by the system, not the application. A value of * <code>null</code> 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 <code>null</code> * * @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 SWT#ICON_ERROR * @see SWT#ICON_INFORMATION * @see SWT#ICON_QUESTION * @see SWT#ICON_WARNING * @see SWT#ICON_WORKING * * @since 3.0 */ public Image getSystemImage(int id) { checkDevice(); switch (id) { case SWT.ICON_ERROR: if (errorImage == null) { errorImage = createImage("gtk-dialog-error"); //$NON-NLS-1$ } return errorImage; case SWT.ICON_INFORMATION: case SWT.ICON_WORKING: if (infoImage == null) { infoImage = createImage("gtk-dialog-info"); //$NON-NLS-1$ } return infoImage; case SWT.ICON_QUESTION: if (questionImage == null) { questionImage = createImage("gtk-dialog-question"); //$NON-NLS-1$ } return questionImage; case SWT.ICON_WARNING: if (warningImage == null) { warningImage = createImage("gtk-dialog-warning"); //$NON-NLS-1$ } return warningImage; } return null; } /** * Returns the single instance of the system-provided menu for the * application, or <code>null</code> on platforms where no menu is provided * for the application. * * @return the system menu, or <code>null</code> * * @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> * * @since 3.7 */ public Menu getSystemMenu() { checkDevice(); return null; } void initializeSystemColors() { COLOR_INFO_FOREGROUND = gdkColorGenerator(0, 0, 0); COLOR_INFO_BACKGROUND = gdkColorGenerator(255, 255, 255); COLOR_WIDGET_DARK_SHADOW = gdkColorGenerator(64, 64, 64); COLOR_WIDGET_NORMAL_SHADOW = gdkColorGenerator(128, 128, 128); COLOR_WIDGET_LIGHT_SHADOW = gdkColorGenerator(212, 208, 200); COLOR_WIDGET_HIGHLIGHT_SHADOW = gdkColorGenerator(192, 192, 192); COLOR_WIDGET_FOREGROUND = gdkColorGenerator(0, 0, 0); COLOR_WIDGET_BACKGROUND = gdkColorGenerator(212, 208, 200); COLOR_LIST_FOREGROUND = gdkColorGenerator(0, 0, 0); COLOR_LIST_BACKGROUND = gdkColorGenerator(255, 255, 255); COLOR_LIST_SELECTION_TEXT = gdkColorGenerator(0, 0, 0); COLOR_LIST_SELECTION = gdkColorGenerator(10, 36, 106); COLOR_TITLE_BACKGROUND = gdkColorGenerator(10, 36, 106); COLOR_TITLE_FOREGROUND = gdkColorGenerator(255, 255, 255); COLOR_TITLE_BACKGROUND_GRADIENT = gdkColorGenerator(166, 202, 240); COLOR_TITLE_INACTIVE_BACKGROUND = gdkColorGenerator(128, 128, 128); COLOR_TITLE_INACTIVE_FOREGROUND = gdkColorGenerator(212, 208, 200); COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT = gdkColorGenerator(192, 192, 192); } private GdkColor gdkColorGenerator(int red, int green, int blue) { GdkColor gdkColor = new GdkColor(); gdkColor.red = (short) ((red & 0xFF) | ((red & 0xFF) << 8)); gdkColor.green = (short) ((green & 0xFF) | ((green & 0xFF) << 8)); gdkColor.blue = (short) ((blue & 0xFF) | ((blue & 0xFF) << 8)); return gdkColor; } /** * Returns a reasonable font for applications to use. On some platforms, * this will match the "default font" or "system font" if such can be found. * This font should not be free'd because it was allocated by the system, * not the application. * <p> * 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. * </p> * * @return a font * * @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 Font getSystemFont() { return new Font(null, new FontData()); } /** * Returns the single instance of the system taskBar or null when there is * no system taskBar available for the platform. * * @return the system taskBar or <code>null</code> * * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * * @since 3.6 */ public TaskBar getSystemTaskBar() { checkDevice(); return null; } /** * Returns the single instance of the system tray or null when there is no * system tray available for the platform. * * @return the system tray or <code>null</code> * * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * * @since 3.0 */ public Tray getSystemTray() { checkDevice(); if (tray != null) return tray; return tray = new Tray(this, SWT.NONE); } /** * Returns the user-interface thread for the receiver. * * @return the receiver's user-interface thread * * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> */ /** * TODO public Thread getThread() { // synchronized (Device.class) { // if * (isDisposed()) // error(SWT.ERROR_DEVICE_DISPOSED); // return thread; // * } System.out.println("Display.getThread() returns null"); return null; } */ /** * Returns a boolean indicating whether a touch-aware input device is * attached to the system and is ready for use. * * @return <code>true</code> if a touch-aware input device is detected, or * <code>false</code> otherwise * * @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> * * @since 3.7 */ public boolean getTouchEnabled() { checkDevice(); return false; } Widget getWidget(long /* int */ handle) { return null; } /** * Initializes any internal resources needed by the device. * <p> * This method is called after <code>create</code>. * </p> * * @see #create */ protected void init() { super.init(); initializeCallbacks(); initializeSubclasses(); initializeSystemColors(); initializeSystemSettings(); initializeWidgetTable(); initializeWindowManager(); } void initializeCallbacks() { } void initializeSubclasses() { } void initializeSystemSettings() { } 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; } void initializeWindowManager() { } /** * Invokes platform specific functionality to dispose a GC handle. * <p> * <b>IMPORTANT:</b> This method is <em>not</em> part of the public API for * <code>Display</code>. 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. * </p> * * @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. */ public void internal_dispose_GC(long /* int */ gdkGC, GCData data) { } /** * Invokes platform specific functionality to allocate a new GC handle. * <p> * <b>IMPORTANT:</b> This method is <em>not</em> part of the public API for * <code>Display</code>. 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. * </p> * * @param data * the platform specific GC data * @return the platform specific GC handle * * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * @exception SWTError * <ul> * <li>ERROR_NO_HANDLES if a handle could not be obtained for * gc creation</li> * </ul> * * @noreference This method is not intended to be referenced by clients. */ public long /* int */ internal_new_GC(GCData data) { return 0; } boolean isValidThread() { return true; } /** * Maps a point from one coordinate system to another. When the control is * null, coordinates are mapped to the display. * <p> * 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. * </p> * * @param from * the source <code>Control</code> or <code>null</code> * @param to * the destination <code>Control</code> or <code>null</code> * @param point * to be mapped * @return point with mapped coordinates * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the point is null</li> * <li>ERROR_INVALID_ARGUMENT - if the Control from or the * Control to have been disposed</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> * * @since 2.1.2 */ public Point map(Control from, Control to, Point point) { checkDevice(); if (point == null) error(SWT.ERROR_NULL_ARGUMENT); return map(from, to, point.x, point.y); } /** * Maps a point from one coordinate system to another. When the control is * null, coordinates are mapped to the display. * <p> * 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. * </p> * * @param from * the source <code>Control</code> or <code>null</code> * @param to * the destination <code>Control</code> or <code>null</code> * @param x * coordinates to be mapped * @param y * coordinates to be mapped * @return point with mapped coordinates * * @exception IllegalArgumentException * <ul> * <li>ERROR_INVALID_ARGUMENT - if the Control from or the * Control to have been disposed</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> * * @since 2.1.2 */ public Point map(Control from, Control to, int x, int y) { return null; } /** * Maps a point from one coordinate system to another. When the control is * null, coordinates are mapped to the display. * <p> * 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. * </p> * * @param from * the source <code>Control</code> or <code>null</code> * @param to * the destination <code>Control</code> or <code>null</code> * @param rectangle * to be mapped * @return rectangle with mapped coordinates * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the rectangle is null</li> * <li>ERROR_INVALID_ARGUMENT - if the Control from or the * Control to have been disposed</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> * * @since 2.1.2 */ public Rectangle map(Control from, Control to, Rectangle rectangle) { checkDevice(); if (rectangle == null) error(SWT.ERROR_NULL_ARGUMENT); return map(from, to, rectangle.x, rectangle.y, rectangle.width, rectangle.height); } /** * Maps a point from one coordinate system to another. When the control is * null, coordinates are mapped to the display. * <p> * 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. * </p> * * @param from * the source <code>Control</code> or <code>null</code> * @param to * the destination <code>Control</code> or <code>null</code> * @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 * <ul> * <li>ERROR_INVALID_ARGUMENT - if the Control from or the * Control to have been disposed</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> * * @since 2.1.2 */ public Rectangle map(Control from, Control to, int x, int y, int width, int height) { return null; } /** * Generate a low level system event. * * <code>post</code> 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. * <p> * 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. * </p> * <p> * <b>Event Types:</b> * <p> * KeyDown, KeyUp * <p> * The following fields in the <code>Event</code> apply: * <ul> * <li>(in) type KeyDown or KeyUp</li> * <p> * Either one of: * <li>(in) character a character that corresponds to a keyboard key</li> * <li>(in) keyCode the key code of the key that was typed, as defined by * the key code constants in class <code>SWT</code></li> * </ul> * <p> * MouseDown, MouseUp * </p> * <p> * The following fields in the <code>Event</code> apply: * <ul> * <li>(in) type MouseDown or MouseUp * <li>(in) button the button that is pressed or released * </ul> * <p> * MouseMove * </p> * <p> * The following fields in the <code>Event</code> apply: * <ul> * <li>(in) type MouseMove * <li>(in) x the x coordinate to move the mouse pointer to in screen * coordinates * <li>(in) y the y coordinate to move the mouse pointer to in screen * coordinates * </ul> * <p> * MouseWheel * </p> * <p> * The following fields in the <code>Event</code> apply: * <ul> * <li>(in) type MouseWheel * <li>(in) detail either SWT.SCROLL_LINE or SWT.SCROLL_PAGE * <li>(in) count the number of lines or pages to scroll * </ul> * </dl> * * @param event * the event to be generated * * @return true if the event was generated or false otherwise * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the event is null</li> * </ul> * @exception SWTException * <ul> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * * @since 3.0 * */ public boolean post(Event event) { return false; } 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. */ if (eventQueue == null) eventQueue = new Event[4]; int index = 0; int length = eventQueue.length; while (index < length) { if (eventQueue[index] == null) break; index++; } if (index == length) { Event[] newQueue = new Event[length + 4]; System.arraycopy(eventQueue, 0, newQueue, 0, length); eventQueue = newQueue; } eventQueue[index] = event; } /** * 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> if the caller can sleep until another * event is placed on the event queue. * <p> * In addition to checking the system event queue, this method also checks * if any inter-thread messages (created by <code>syncExec()</code> or * <code>asyncExec()</code>) are waiting to be processed, and if so handles * them before returning. * </p> * * @return <code>false</code> if the caller can sleep upon return from this * method * * @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> * <li>ERROR_FAILED_EXEC - if an exception occurred while * running an inter-thread message</li> * </ul> * * @see #sleep * @see #wake */ public boolean readAndDispatch() { return false; } static void register(Display display) { synchronized (Device.class) { for (int i = 0; i < Displays.length; i++) { if (Displays[i] == null) { Displays[i] = display; return; } } Display[] newDisplays = new Display[Displays.length + 4]; System.arraycopy(Displays, 0, newDisplays, 0, Displays.length); newDisplays[Displays.length] = display; Displays = newDisplays; } } /** * Releases any internal resources back to the operating system and clears * all fields except the device handle. * <p> * Disposes all shells which are currently open on the display. After this * method has been invoked, all related related shells will answer * <code>true</code> when sent the message <code>isDisposed()</code>. * </p> * <p> * 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 <code>release</code>. 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 <code>destroy</code>. * </p> * This method is called before <code>destroy</code>. * * @see Device#dispose * @see #destroy */ protected void release() { } /** * Removes the listener from 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>. * * @param eventType * the type of event to listen for * @param listener * the listener which should no longer 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> * </ul> * * @see Listener * @see SWT * @see #addFilter * @see #addListener * * @since 3.0 */ public void removeFilter(int eventType, Listener listener) { checkDevice(); if (listener == null) error(SWT.ERROR_NULL_ARGUMENT); if (filterTable == null) return; filterTable.unhook(eventType, listener); if (filterTable.size() == 0) filterTable = null; } /** * Removes the listener from 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>. * * @param eventType * the type of event to listen for * @param listener * the listener which should no longer be notified * * @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 #addListener * * @since 2.0 */ public void removeListener(int eventType, Listener listener) { checkDevice(); if (listener == null) error(SWT.ERROR_NULL_ARGUMENT); if (eventTable == null) return; eventTable.unhook(eventType, listener); } void removePopup(Menu menu) { if (popups == null) return; for (int i = 0; i < popups.length; i++) { if (popups[i] == menu) { popups[i] = null; return; } } } boolean runSkin() { return false; } /** * Returns the application name. * * @return the application name * * @see #setAppName(String) * * @since 3.6 */ public static String getAppName() { return APP_NAME; } /** * Returns the application version. * * @return the application version * * @see #setAppVersion(String) * * @since 3.6 */ public static String getAppVersion() { return APP_VERSION; } /** * Sets the application name to the argument. * <p> * The application name can be used in several ways, depending on the * platform and tools being used. On Motif, for example, this can be used to * set the name used for resource lookup. Accessibility tools may also ask * for the application name. * </p> * <p> * Specifying <code>null</code> for the name clears it. * </p> * * @param name * the new app name or <code>null</code> */ 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; } /** * Sets the location of the on-screen pointer relative to the top left * corner of the screen. <b>Note: It is typically considered bad practice * for a program to move the on-screen pointer location.</b> * * @param x * the new x coordinate for the cursor * @param y * the new y coordinate for the cursor * * @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> * * @since 2.1 */ public void setCursorLocation(int x, int y) { } /** * Sets the location of the on-screen pointer relative to the top left * corner of the screen. <b>Note: It is typically considered bad practice * for a program to move the on-screen pointer location.</b> * * @param point * new position * * @exception SWTException * <ul> * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the * thread that created the receiver</li> * <li>ERROR_NULL_ARGUMENT - if the point is null * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * * @since 2.0 */ public void setCursorLocation(Point point) { checkDevice(); if (point == null) error(SWT.ERROR_NULL_ARGUMENT); setCursorLocation(point.x, point.y); } /** * Sets the application defined property of the receiver with the specified * name to the given argument. * <p> * 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 <code>disposeExec()</code> handler which does so. * </p> * * @param key * the name of the property * @param value * the new value for the property * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the key 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 #getData(String) * @see #disposeExec(Runnable) */ public void setData(String key, Object value) { } /** * Sets the application defined, display specific data associated with the * receiver, to the argument. The <em>display specific data</em> is a * single, unnamed field that is stored with every display. * <p> * 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 * <code>disposeExec()</code> handler which does so. * </p> * * @param data * the new display specific data * * @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 #getData() * @see #disposeExec(Runnable) */ public void setData(Object data) { checkDevice(); this.data = data; } /** * Sets the synchronizer used by the display to be the argument, which can * not be null. * * @param synchronizer * the new synchronizer for the display (must not be null) * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the synchronizer 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> * <li>ERROR_FAILED_EXEC - if an exception occurred while * running an inter-thread message</li> * </ul> */ public void setSynchronizer(Synchronizer synchronizer) { } /** * Causes the user-interface thread to <em>sleep</em> (that is, to be put in * a state where it does not consume CPU cycles) until an event is received * or it is otherwise awakened. * * @return <code>true</code> if an event requiring dispatching was placed on * the queue. * * @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 #wake */ public boolean sleep() { return false; } /** * Causes the <code>run()</code> 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. * <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 milliseconds * the delay before running the runnable * @param runnable * code to run on the user-interface thread * * @exception IllegalArgumentException * <ul> * <li>ERROR_NULL_ARGUMENT - if the runnable 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 #asyncExec */ public void timerExec(int milliseconds, final Runnable runnable) { Timer execTimer = new Timer() { @Override public void run() { runnable.run(); } }; execTimer.schedule(milliseconds); } void sendEvent(int eventType, Event event) { if (eventTable == null && filterTable == null) { return; } if (event == null) event = new Event(); event.display = this; event.type = eventType; if (event.time == 0) event.time = getLastEventTime(); if (!filterEvent(event)) { if (eventTable != null) eventTable.sendEvent(event); } } void setCurrentCaret(Caret caret) { } /** * Causes the <code>run()</code> 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 <code>null</code> as the runnable simply wakes the * user-interface thread. * <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_FAILED_EXEC - if an exception occurred when * executing the runnable</li> * <li>ERROR_DEVICE_DISPOSED - if the receiver has been * disposed</li> * </ul> * * @see #asyncExec */ public void syncExec(Runnable runnable) { } public void wake() { } void wakeThread() { } /** * Forces all outstanding paint requests for the display to be processed * before this method returns. * * @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 Control#update() */ public void update() { } }