Class Display

java.lang.Object
org.eclipse.swt.graphics.Device
org.eclipse.swt.widgets.Display
All Implemented Interfaces:
Executor, Drawable
public class Display extends Device implements Executor
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.

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.

The user-interface thread for a particular display has the following special attributes:
  • The event loop for that display must be run from the thread.
  • Some SWT API methods (notably, most of the public methods in 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.)
  • The thread is not allowed to construct other 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.

Styles:
(none)
Events:
Close, Dispose, OpenDocument, Settings, Skin

IMPORTANT: This class is not intended to be subclassed.

See Also:

  • Field Details

    • SLOT_IN_USE

      private static final int SLOT_IN_USE
      See Also:

    • LAST_TABLE_INDEX

      private static final int LAST_TABLE_INDEX
      See Also:

    • gdkEventCount

      int gdkEventCount

    • gdkEvents

      long[] gdkEvents

    • gdkEventWidgets

      Widget[] gdkEventWidgets

    • dispatchEvents

      int[] dispatchEvents

    • eventQueue

      Event[] eventQueue

    • fds

      long fds

    • allocated_nfds

      int allocated_nfds

    • wake

      boolean wake

    • windowSizeSet

      boolean windowSizeSet

    • max_priority

      int[] max_priority

    • timeout

      int[] timeout

    • eventCallback

      Callback eventCallback

    • eventProc

      long eventProc

    • windowProc2

      long windowProc2

    • windowProc3

      long windowProc3

    • windowProc4

      long windowProc4

    • windowProc5

      long windowProc5

    • windowProc6

      long windowProc6

    • changeValueProc

      long changeValueProc

    • snapshotDrawProc

      long snapshotDrawProc

    • keyPressReleaseProc

      long keyPressReleaseProc

    • focusProc

      long focusProc

    • windowActiveProc

      long windowActiveProc

    • enterMotionProc

      long enterMotionProc

    • leaveProc

      long leaveProc

    • scrollProc

      long scrollProc

    • resizeProc

      long resizeProc

    • activateProc

      long activateProc

    • gesturePressReleaseProc

      long gesturePressReleaseProc

    • notifyProc

      long notifyProc

    • computeSizeProc

      long computeSizeProc

    • windowCallback2

      Callback windowCallback2

    • windowCallback3

      Callback windowCallback3

    • windowCallback4

      Callback windowCallback4

    • windowCallback5

      Callback windowCallback5

    • windowCallback6

      Callback windowCallback6

    • changeValue

      Callback changeValue

    • snapshotDraw

      Callback snapshotDraw

    • keyPressReleaseCallback

      Callback keyPressReleaseCallback

    • focusCallback

      Callback focusCallback

    • windowActiveCallback

      Callback windowActiveCallback

    • enterMotionCallback

      Callback enterMotionCallback

    • computeSizeCallback

      Callback computeSizeCallback

    • scrollCallback

      Callback scrollCallback

    • leaveCallback

      Callback leaveCallback

    • resizeCallback

      Callback resizeCallback

    • activateCallback

      Callback activateCallback

    • gesturePressReleaseCallback

      Callback gesturePressReleaseCallback

    • notifyCallback

      Callback notifyCallback

    • eventTable

      EventTable eventTable

    • filterTable

      EventTable filterTable

    • APP_NAME

      static String APP_NAME

    • APP_VERSION

      static String APP_VERSION

    • DISPATCH_EVENT_KEY

      static final String DISPATCH_EVENT_KEY
      See Also:

    • ADD_WIDGET_KEY

      static final String ADD_WIDGET_KEY
      See Also:

    • EXTERNAL_EVENT_LOOP_KEY

      static final String EXTERNAL_EVENT_LOOP_KEY
      See Also:

    • closures

      long[] closures

    • closuresProc

      long[] closuresProc

    • closuresCount

      int[] closuresCount

    • signalIds

      int[] signalIds

    • shellMapProcClosure

      long shellMapProcClosure

    • externalEventLoop

      boolean externalEventLoop

    • indexTable

      int[] indexTable

    • freeSlot

      int freeSlot

    • lastHandle

      long lastHandle

    • lastWidget

      Widget lastWidget

    • widgetTable

      Widget[] widgetTable

    • GROW_SIZE

      static final int GROW_SIZE
      See Also:

    • SWT_OBJECT_INDEX

      static final int SWT_OBJECT_INDEX

    • SWT_OBJECT_INDEX1

      static final int SWT_OBJECT_INDEX1

    • SWT_OBJECT_INDEX2

      static final int SWT_OBJECT_INDEX2

    • modalShells

      Shell[] modalShells

    • modalDialog

      Dialog modalDialog

    • GET_MODAL_DIALOG

      static final String GET_MODAL_DIALOG
      See Also:

    • SET_MODAL_DIALOG

      static final String SET_MODAL_DIALOG
      See Also:

    • focusEvent

      int focusEvent

    • focusControl

      Control focusControl

    • activeShell

      Shell activeShell

    • activePending

      boolean activePending

    • ignoreActivate

      boolean ignoreActivate

    • ignoreFocus

      boolean ignoreFocus

    • tracker

      Tracker tracker

    • imControl

      Control imControl

    • preeditWindow

      long preeditWindow

    • preeditLabel

      long preeditLabel

    • synchronizer

      Synchronizer synchronizer

    • runtimeExceptionHandler

      Consumer<RuntimeException> runtimeExceptionHandler

    • errorHandler

      Consumer<Error> errorHandler

    • thread

      Thread thread

    • sessionManagerDBus

      SessionManagerDBus sessionManagerDBus

    • sessionManagerListener

      Display.SessionManagerListener sessionManagerListener

    • disposeList

      Runnable[] disposeList

    • layoutDeferred

      Composite[] layoutDeferred

    • layoutDeferredCount

      int layoutDeferredCount

    • tray

      Tray tray

    • currentTrayItem

      TrayItem currentTrayItem

    • timerIds

      int[] timerIds

    • timerList

      Runnable[] timerList

    • timerCallback

      Callback timerCallback

    • timerProc

      long timerProc

    • windowTimerCallback

      Callback windowTimerCallback

    • windowTimerProc

      long windowTimerProc

    • currentCaret

      Caret currentCaret

    • caretCallback

      Callback caretCallback

    • caretId

      int caretId

    • caretProc

      long caretProc

    • mnemonicControl

      Control mnemonicControl

    • mouseHoverId

      int mouseHoverId

    • mouseHoverHandle

      long mouseHoverHandle

    • mouseHoverProc

      long mouseHoverProc

    • mouseHoverCallback

      Callback mouseHoverCallback

    • sizeAllocateProc

      long sizeAllocateProc

    • sizeAllocateCallback

      Callback sizeAllocateCallback

    • sizeRequestProc

      long sizeRequestProc

    • sizeRequestCallback

      Callback sizeRequestCallback

    • shellMapProc

      long shellMapProc

    • shellMapCallback

      Callback shellMapCallback

    • idleProc

      long idleProc

    • idleHandle

      int idleHandle

    • idleCallback

      Callback idleCallback

    • ADD_IDLE_PROC_KEY

      static final String ADD_IDLE_PROC_KEY
      See Also:

    • REMOVE_IDLE_PROC_KEY

      static final String REMOVE_IDLE_PROC_KEY
      See Also:

    • idleLock

      Object idleLock

    • idleNeeded

      boolean idleNeeded

    • cellDataProc

      long cellDataProc

    • cellDataCallback

      Callback cellDataCallback

    • setDirectionProc

      long setDirectionProc

    • setDirectionCallback

      Callback setDirectionCallback

    • GET_DIRECTION_PROC_KEY

      static final String GET_DIRECTION_PROC_KEY
      See Also:

    • emissionProc

      long emissionProc

    • emissionProcCallback

      Callback emissionProcCallback

    • GET_EMISSION_PROC_KEY

      static final String GET_EMISSION_PROC_KEY
      See Also:

    • allChildrenProc

      long allChildrenProc

    • allChildren

      long allChildren

    • allChildrenCallback

      Callback allChildrenCallback

    • signalProc

      long signalProc

    • signalCallback

      Callback signalCallback

    • shellHandle

      long shellHandle

    • settingsChanged

      boolean settingsChanged

    • runSettings

      boolean runSettings

    • STYLE_UPDATED

      static final int STYLE_UPDATED
      See Also:

    • entrySelectOnFocus

      boolean entrySelectOnFocus

    • currentControl

      Control currentControl

    • checkIfEventProc

      long checkIfEventProc

    • checkIfEventCallback

      Callback checkIfEventCallback

    • flushWindow

      long flushWindow

    • flushAll

      boolean flushAll

    • flushRect

      GdkRectangle flushRect

    • exposeEvent

      XExposeEvent exposeEvent

    • flushData

      long[] flushData

    • errorImage

      Image errorImage

    • infoImage

      Image infoImage

    • questionImage

      Image questionImage

    • warningImage

      Image warningImage

    • cursors

      Cursor[] cursors

    • resources

      Resource[] resources

    • RESOURCE_SIZE

      static final int RESOURCE_SIZE
      See Also:

    • COLOR_WIDGET_DARK_SHADOW_RGBA

      GdkRGBA COLOR_WIDGET_DARK_SHADOW_RGBA

    • COLOR_WIDGET_NORMAL_SHADOW_RGBA

      GdkRGBA COLOR_WIDGET_NORMAL_SHADOW_RGBA

    • COLOR_WIDGET_LIGHT_SHADOW_RGBA

      GdkRGBA COLOR_WIDGET_LIGHT_SHADOW_RGBA

    • COLOR_WIDGET_HIGHLIGHT_SHADOW_RGBA

      GdkRGBA COLOR_WIDGET_HIGHLIGHT_SHADOW_RGBA

    • COLOR_WIDGET_BACKGROUND_RGBA

      GdkRGBA COLOR_WIDGET_BACKGROUND_RGBA

    • COLOR_WIDGET_FOREGROUND_RGBA

      GdkRGBA COLOR_WIDGET_FOREGROUND_RGBA

    • COLOR_WIDGET_BORDER_RGBA

      GdkRGBA COLOR_WIDGET_BORDER_RGBA

    • COLOR_LIST_FOREGROUND_RGBA

      GdkRGBA COLOR_LIST_FOREGROUND_RGBA

    • COLOR_LIST_BACKGROUND_RGBA

      GdkRGBA COLOR_LIST_BACKGROUND_RGBA

    • COLOR_LIST_SELECTION_RGBA

      GdkRGBA COLOR_LIST_SELECTION_RGBA

    • COLOR_LIST_SELECTION_TEXT_RGBA

      GdkRGBA COLOR_LIST_SELECTION_TEXT_RGBA

    • COLOR_LIST_SELECTION_INACTIVE_RGBA

      GdkRGBA COLOR_LIST_SELECTION_INACTIVE_RGBA

    • COLOR_LIST_SELECTION_TEXT_INACTIVE_RGBA

      GdkRGBA COLOR_LIST_SELECTION_TEXT_INACTIVE_RGBA

    • COLOR_INFO_BACKGROUND_RGBA

      GdkRGBA COLOR_INFO_BACKGROUND_RGBA

    • COLOR_INFO_FOREGROUND_RGBA

      GdkRGBA COLOR_INFO_FOREGROUND_RGBA

    • COLOR_TITLE_FOREGROUND_RGBA

      GdkRGBA COLOR_TITLE_FOREGROUND_RGBA

    • COLOR_TITLE_BACKGROUND_RGBA

      GdkRGBA COLOR_TITLE_BACKGROUND_RGBA

    • COLOR_TITLE_BACKGROUND_GRADIENT_RGBA

      GdkRGBA COLOR_TITLE_BACKGROUND_GRADIENT_RGBA

    • COLOR_TITLE_INACTIVE_FOREGROUND_RGBA

      GdkRGBA COLOR_TITLE_INACTIVE_FOREGROUND_RGBA

    • COLOR_TITLE_INACTIVE_BACKGROUND_RGBA

      GdkRGBA COLOR_TITLE_INACTIVE_BACKGROUND_RGBA

    • COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT_RGBA

      GdkRGBA COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT_RGBA

    • COLOR_WIDGET_DISABLED_FOREGROUND_RGBA

      GdkRGBA COLOR_WIDGET_DISABLED_FOREGROUND_RGBA

    • COLOR_TEXT_DISABLED_BACKGROUND_RGBA

      GdkRGBA COLOR_TEXT_DISABLED_BACKGROUND_RGBA

    • COLOR_TOGGLE_BUTTON_FOREGROUND_RGBA

      GdkRGBA COLOR_TOGGLE_BUTTON_FOREGROUND_RGBA

    • colorList

      ArrayList<String> colorList

    • SWT_COLOR_LIST_SELECTION_TEXT_INACTIVE

      final int SWT_COLOR_LIST_SELECTION_TEXT_INACTIVE
      See Also:

    • SWT_COLOR_LIST_SELECTION_INACTIVE

      final int SWT_COLOR_LIST_SELECTION_INACTIVE
      See Also:

    • themeName

      static String themeName
      The name of the current theme, including the theme named by GTK_THEME.

    • themeDark

      static boolean themeDark
      True if the current theme is dark. This includes the theme set in GTK_THEME.

    • colorPattern

      private static final Pattern colorPattern

    • popups

      Menu[] popups

    • clickCount

      int clickCount

    • INNER_BORDER

      static final int INNER_BORDER
      See Also:

    • lastEventTime

      int lastEventTime

    • lastUserEventTime

      int lastUserEventTime

    • pangoLayoutNewProc

      long pangoLayoutNewProc

    • pangoFontFamilyNewProc

      long pangoFontFamilyNewProc

    • pangoFontFaceNewProc

      long pangoFontFaceNewProc

    • imContextNewProc

      long imContextNewProc

    • printerOptionWidgetNewProc

      long printerOptionWidgetNewProc

    • resizeLocationX

      double resizeLocationX

    • resizeLocationY

      double resizeLocationY

    • resizeBoundsX

      int resizeBoundsX

    • resizeBoundsY

      int resizeBoundsY

    • resizeBoundsWidth

      int resizeBoundsWidth

    • resizeBoundsHeight

      int resizeBoundsHeight

    • resizeMode

      int resizeMode

    • fixed_type

      static long fixed_type

    • text_renderer_type

      static long text_renderer_type

    • pixbuf_renderer_type

      static long pixbuf_renderer_type

    • toggle_renderer_type

      static long toggle_renderer_type

    • text_renderer_info_ptr

      static long text_renderer_info_ptr

    • pixbuf_renderer_info_ptr

      static long pixbuf_renderer_info_ptr

    • toggle_renderer_info_ptr

      static long toggle_renderer_info_ptr

    • rendererClassInitCallback

      static Callback rendererClassInitCallback

    • rendererRenderCallback

      static Callback rendererRenderCallback

    • rendererSnapshotCallback

      static Callback rendererSnapshotCallback

    • rendererGetPreferredWidthCallback

      static Callback rendererGetPreferredWidthCallback

    • rendererClassInitProc

      static long rendererClassInitProc

    • rendererRenderProc

      static long rendererRenderProc

    • rendererSnapshotProc

      static long rendererSnapshotProc

    • rendererGetPreferredWidthProc

      static long rendererGetPreferredWidthProc

    • KeyTable

      static final int[][] KeyTable

    • cachedModifierState

      int cachedModifierState

    • latinKeyGroup

      private int latinKeyGroup

    • groupKeysCount

      Map<Integer,Integer> groupKeysCount

    • keysChangedProc

      long keysChangedProc

    • keysChangedCallback

      Callback keysChangedCallback

    • settingsChangedProc

      long settingsChangedProc

    • settingsChangedCallback

      Callback settingsChangedCallback

    • Default

      static Display Default

    • Displays

      static Display[] Displays

    • skinList

      Widget[] skinList

    • skinCount

      int skinCount

    • PACKAGE_PREFIX

      static final String PACKAGE_PREFIX
      See Also:

    • GTK3_MAJOR

      static final int GTK3_MAJOR
      See Also:

    • GTK3_MINOR

      static final int GTK3_MINOR
      See Also:

    • GTK3_MICRO

      static final int GTK3_MICRO
      See Also:

    • GTK4_MAJOR

      static final int GTK4_MAJOR
      See Also:

    • GTK4_MINOR

      static final int GTK4_MINOR
      See Also:

    • GTK4_MICRO

      static final int GTK4_MICRO
      See Also:

    • data

      Object data

    • keys

      String[] keys

    • values

      Object[] values

    • TRIM_NONE

      static final int TRIM_NONE
      See Also:

    • TRIM_BORDER

      static final int TRIM_BORDER
      See Also:

    • TRIM_RESIZE

      static final int TRIM_RESIZE
      See Also:

    • TRIM_TITLE_BORDER

      static final int TRIM_TITLE_BORDER
      See Also:

    • TRIM_TITLE_RESIZE

      static final int TRIM_TITLE_RESIZE
      See Also:

    • TRIM_TITLE

      static final int TRIM_TITLE
      See Also:

    • trimWidths

      int[] trimWidths

    • trimHeights

      int[] trimHeights

    • ignoreTrim

      boolean ignoreTrim

    • windowManager

      String windowManager

  • Constructor Details

    • Display

      public Display()
      Constructs a new instance of this class.

      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.

      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if called from a thread that already created an existing display
      • ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
      See Also:

    • Display

      public Display(DeviceData data)
      Constructs a new instance of this class using the parameter.
      Parameters:
      data - the device data

  • Method Details

    • setDevice

      static void setDevice(Device device)

    • addFilter

      public void addFilter(int eventType, Listener listener)
      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 SWT. 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.

      Parameters:
      eventType - the type of event to listen for
      listener - the listener which should be notified when the event occurs
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the listener is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0
      See Also:

    • addLayoutDeferred

      void addLayoutDeferred(Composite comp)

    • addGdkEvent

      void addGdkEvent(long event)

    • addIdleProc

      void addIdleProc()

    • addListener

      public void addListener(int eventType, Listener listener)
      Adds the listener to the collection of listeners who will be notified when an event of the given type occurs. The event type is one of the event constants defined in class SWT. When the event does occur in the display, the listener is notified by sending it the handleEvent() message.
      Parameters:
      eventType - the type of event to listen for
      listener - the listener which should be notified when the event occurs
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the listener is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.0
      See Also:

    • gdbus_init_methods

      private void gdbus_init_methods()
      Handle gdbus on 'org.eclipse.swt' DBus session. E.g equinox launcher passes files/urls to SWT via gdbus. "./eclipse myFile" or "./eclipse http://www.google.com" Only one SWT instance can hold the unique and well-known name at one time. We construct the name as org.eclipse.swt.NAME (e.g. org.eclipse.swt.Eclipse), where NAME is derived from the application executable but may be changed using the command-line argument -name. For equinox launcher, See eclipseGtk.c:gtkPlatformJavaSystemProperties

    • allChildrenProc

      long allChildrenProc(long widget, long recurse)

    • addMouseHoverTimeout

      void addMouseHoverTimeout(long handle)

    • addPopup

      void addPopup(Menu menu)

    • addSkinnableWidget

      void addSkinnableWidget(Widget widget)

    • addWidget

      void addWidget(long handle, Widget widget)

    • asyncExec

      public void asyncExec(Runnable runnable)
      Causes the run() 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 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.

      Parameters:
      runnable - code to run on the user-interface thread or null
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • execute

      public void execute(Runnable runnable)
      Executes the given runnable in the user-interface thread of this Display.
      • If the calling thread is the user-interface thread of this display it is executed immediately and the method returns after the command has run, as with the method syncExec(Runnable).
      • In all other cases the run() method of the runnable is asynchronously executed as with the method asyncExec(Runnable) at the next reasonable opportunity. The caller of this method continues to run in parallel, and is not notified when the runnable has completed.

      This can be used in cases where one want to execute some piece of code that should be guaranteed to run in the user-interface thread regardless of the current thread.

      Note that at the time the runnable is invoked, widgets that have the receiver as their display may have been disposed. Therefore, it is advised to check for this case inside the runnable before accessing the widget.

      Specified by:
      execute in interface Executor
      Parameters:
      runnable - the runnable to execute in the user-interface thread, never null
      Throws:
      RejectedExecutionException - if this task cannot be accepted for execution
      NullPointerException - if runnable is null

    • beep

      public void beep()
      Causes the system hardware to emit a short sound (if it supports this capability).
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • cellDataProc

      long cellDataProc(long tree_column, long cell, long tree_model, long iter, long data)

    • checkDevice

      protected void checkDevice()
      Description copied from class: Device
      Throws an SWTException if the receiver can not be accessed by the caller. This may include both checks on the state of the receiver and more generally on the entire execution context. This method should be called by device implementors to enforce the standard SWT invariants.

      Currently, it is an error to invoke any method (other than isDisposed() and dispose()) on a device that has had its dispose() method called.

      In future releases of SWT, there may be more or fewer error checks and exceptions may be thrown for different reasons.

      Overrides:
      checkDevice in class Device

    • checkDisplay

      static void checkDisplay(Thread thread, boolean multiple)

    • checkIfEventProc

      long checkIfEventProc(long display, long xEvent, long userData)

    • checkSubclass

      protected void checkSubclass()
      Checks that this class can be subclassed.

      IMPORTANT: See the comment in Widget.checkSubclass().

      Throws:
      SWTException -
      • ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass
      See Also:

    • clearModal

      void clearModal(Shell shell)

    • close

      public void close()
      Requests that the connection between SWT and the underlying operating system be closed.
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.0
      See Also:

    • create

      protected void create(DeviceData data)
      Creates the device in the operating system. If the device does not have a handle, this method may do nothing depending on the device.

      This method is called before init.

      Overrides:
      create in class Device
      Parameters:
      data - the DeviceData which describes the receiver
      See Also:

    • checkIMModule

      void checkIMModule()
      Check if the XIM module is present and generates a warning for potential graphical issues if GTK_IM_MODULE=xim is detected. See Bug 517671. Additionally, this method enforces IBus as the input method for SWT-GTK on GNOME. This is because GNOME forces IBus by default, so any discrepancy can cause crashes on newer versions of GTK3.

    • checkAndSetThemeDetails

      boolean checkAndSetThemeDetails(String themeName)
      Sets the org.eclipse.swt.internal.gtk.theme value with the current GTK theme name. Checks if the current theme SWT is running with is dark or not. This includes checking the GTK_THEME environment variable, the theme name, and GSettings.
      Parameters:
      themeName - the full name of the current theme SWT is running with
      Returns:
      true if the current theme is dark

    • createDisplay

      void createDisplay(DeviceData data)

    • findLatinKeyGroup

      private int findLatinKeyGroup()
      Determine key group of Latin layout, and update the layout group to key count map. If there are multiple Latin keyboard layout group, return the first one.
      Returns:
      the most Latin keyboard layout group (i.e. group holding the max number of Latin alphabet keys)

    • getLatinKeyGroup

      int getLatinKeyGroup()
      Return the most Latin keyboard layout group.

    • getGroupKeysCount

      Map<Integer,Integer> getGroupKeysCount()
      Return a mapping from layout group to the number of Latin alphabet (a-z) in each group

    • keysChangedProc

      long keysChangedProc(long keymap, long user_data)
      'keys-changed' event handler. Updates the most Latin keyboard layout group field.

    • settingsChangedProc

      long settingsChangedProc(long settings, long key, long user_data)
      GtkSettings 'changed' event handler.

    • createImage

      Image createImage(String name)

    • deregister

      static void deregister(Display display)

    • destroy

      protected void destroy()
      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.

      This method is called after release.

      Overrides:
      destroy in class Device
      See Also:

    • destroyDisplay

      void destroyDisplay()

    • emissionProc

      long emissionProc(long ihint, long n_param_values, long param_values, long data)

    • findDisplay

      public static Display findDisplay(Thread thread)
      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 null as the thread will return null for the display.
      Parameters:
      thread - the user-interface thread
      Returns:
      the display for the given thread

    • disposeExec

      public void disposeExec(Runnable runnable)
      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.
      Parameters:
      runnable - code to run at dispose time.
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • error

      void error(int code)
      Does whatever display specific cleanup is required, and then uses the code in SWTError.error to handle the error.
      Parameters:
      code - the descriptive error code
      See Also:
      • invalid reference 
        SWTError#error

    • eventProc

      long eventProc(long event, long data)

    • findWidget

      public Widget findWidget(long handle)
      Given the operating system handle for a widget, returns the instance of the 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.

      Parameters:
      handle - the handle for the widget
      Returns:
      the SWT widget that the handle represents
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • findWidget

      public Widget findWidget(long handle, long id)
      Given the operating system handle for a widget, and widget-specific id, returns the instance of the Widget 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.

      Parameters:
      handle - the handle for the widget
      id - the id for the subwidget (usually an item)
      Returns:
      the SWT widget that the handle/id pair represents
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.1

    • findWidget

      public Widget findWidget(Widget widget, long id)
      Given a widget and a widget-specific id, returns the instance of the Widget subclass which represents the widget/id pair in the currently running application, if such exists, or null if no matching widget can be found.
      Parameters:
      widget - the widget
      id - the id for the subwidget (usually an item)
      Returns:
      the SWT subwidget (usually an item) that the widget/id pair represents
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.3

    • rendererClassInitProc

      static long rendererClassInitProc(long g_class, long class_data)

    • snapshotDrawProc

      void snapshotDrawProc(long handle, long snapshot)

    • rendererGetPreferredWidthProc

      static long rendererGetPreferredWidthProc(long cell, long handle, long minimun_size, long natural_size)

    • rendererRenderProc

      static long rendererRenderProc(long cell, long cr, long handle, long background_area, long cell_area, long flags)

    • rendererSnapshotProc

      static long rendererSnapshotProc(long cell, long snapshot, long handle, long background_area, long cell_area, long flags)

    • flushExposes

      void flushExposes(long window, boolean all)

    • getActiveShell

      public Shell getActiveShell()
      Returns the currently active Shell, or null if no shell belonging to the currently running application is active.
      Returns:
      the active shell or null
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getBounds

      public Rectangle getBounds()
      Returns a rectangle describing the receiver's size and location. Note that on multi-monitor systems the origin can be negative.
      Overrides:
      getBounds in class Device
      Returns:
      the bounding rectangle
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getClientArea

      public Rectangle getClientArea()
      Returns a rectangle which describes the area of the receiver which is capable of displaying data.
      Overrides:
      getClientArea in class Device
      Returns:
      the client area
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • getBoundsInPixels

      Rectangle getBoundsInPixels()

    • getCurrent

      public static Display getCurrent()
      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.
      Returns:
      the current display

    • getCaretBlinkTime

      int getCaretBlinkTime()

    • getClosure

      long getClosure(int id)

    • getCursorControl

      public Control getCursorControl()
      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.
      Returns:
      the control under the cursor or null
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • filterEvent

      boolean filterEvent(Event event)

    • filters

      boolean filters(int eventType)

    • getCursorLocation

      public Point getCursorLocation()
      Returns the location of the on-screen pointer relative to the top left corner of the screen.
      Returns:
      the cursor location
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getCursorSizes

      public Point[] getCursorSizes()
      Returns an array containing the recommended cursor sizes.
      Returns:
      the array of cursor sizes
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0

    • getData

      public Object getData(String key)
      Returns the application defined property of the receiver with the specified name, or null if it has not been set.

      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.

      Parameters:
      key - the name of the property
      Returns:
      the value of the property or null if it has not been set
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the key is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • getData

      public Object getData()
      Returns the application defined, display specific data associated with the receiver, or null if it has not been set. The display specific data is a single, unnamed field that is stored with every display.

      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.

      Returns:
      the display specific data
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • gtk_fixed_get_type

      long gtk_fixed_get_type()

    • gtk_cell_renderer_text_get_type

      long gtk_cell_renderer_text_get_type()

    • gtk_cell_renderer_pixbuf_get_type

      long gtk_cell_renderer_pixbuf_get_type()

    • gtk_cell_renderer_toggle_get_type

      long gtk_cell_renderer_toggle_get_type()

    • gtk_css_create_css_color_string

      String gtk_css_create_css_color_string(String background, String foreground, int property)

    • gtk_css_parse_background

      GdkRGBA gtk_css_parse_background(String css, String precise)
      This method allows for parsing of background colors from a GTK CSS string. It allows for specific search input, such as a selector or tag, or for parsing the first (and usually only) background color in a given GtkCssProvider. For example: given the string GtkWidget {background-color: rgba(255, 0, 0, 255);} this method will return a GdkRGBA object with the color red. Supported formats include "background-color" and just "background".
      Parameters:
      css - a CSS being parsed
      precise - a String representation of a selector to search for, or NULL if the entire GtkCssProvider is to be parsed
      Returns:
      a GdkRGBA object representing the background color, or COLOR_WIDGET_BACKGROUND if the background color could not be parsed or isn't set

    • gtk_css_provider_to_string

      String gtk_css_provider_to_string(long provider)

    • gtk_css_parse_foreground

      GdkRGBA gtk_css_parse_foreground(String css, String precise)
      This method allows for parsing of foreground colors from a GTK CSS string. It allows for specific search input, such as a selector or tag, or for parsing the first (and usually only) foreground color in a given GtkCssProvider. For example: given the string GtkWidget {color: rgba(255, 0, 0, 255);} this method will return a GdkRGBA object with the color red.
      Parameters:
      css - a CSS representation of the gtk theme
      precise - a String representation of a selector to search for, or NULL if the entire GtkCssProvider is to be parsed
      Returns:
      a GdkRGBA object representing the foreground color or COLOR_WIDGET_FOREGROUND if the foreground color could not be parsed or isn't set

    • gtk_css_property_to_rgba

      GdkRGBA gtk_css_property_to_rgba(String property)
      This method parses a string representation of a color and returns a GdkRGBA object of that color. Supported formats: -a standard X11 color -a hex value in the form "#rgb", "#rrggbb", "#rrrgggbbb" or "rrrrggggbbbb" -an RGB color in the for "rgb(r,g,b)" -an RGBA color in the form "rgba(r,g,b,a)"
      Parameters:
      property - a String representation of the color
      Returns:
      a GdkRGBA object representing the color, or transparent (empty GdkRGBA) if the color could not be parsed

    • gtk_rgba_to_css_string

      String gtk_rgba_to_css_string(GdkRGBA rgba)
      In GdkRGBA, values are a double between 0-1. In CSS, values are integers between 0-255 for r, g, and b. Alpha is still a double between 0-1. The final CSS format is: rgba(int, int, int, double) Due to this, there is a slight loss of precision. Setting/getting with CSS *might* yield slight differences.
      Parameters:
      rgba - a GdkRGBA object containing the color to be parsed or NULL
      Returns:
      a String representation of the color or COLOR_WIDGET_BACKGROUND if NULL is specified as a parameter

    • gtk_widget_get_name

      String gtk_widget_get_name(long handle)
      Gets the name of the widget in String format.
      Parameters:
      handle - a pointer to the GtkWidget resource
      Returns:
      a String representation of the widget's name

    • gtk_widget_class_get_css_name

      String gtk_widget_class_get_css_name(long handle)
      Gets the CSS name of the widget provided. This only works on GTK3.20+.
      Parameters:
      handle - a pointer to the GtkWidget resource
      Returns:
      a String representation of the widget's CSS name

    • getDefault

      public static Display getDefault()
      Returns the default display. One is created (making the thread that invokes this method its user-interface thread) if it did not already exist.
      Returns:
      the default display

    • isValidClass

      static boolean isValidClass(Class<?> clazz)

    • getMenuBar

      public Menu getMenuBar()
      Returns the single instance of the application menu bar, or null if there is no application menu bar for the platform.
      Returns:
      the application menu bar, or null
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.7

    • getDismissalAlignment

      public int getDismissalAlignment()
      Returns the button dismissal alignment, one of 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.
      Returns:
      the button dismissal order
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.1

    • getDoubleClickTime

      public int getDoubleClickTime()
      Returns the longest duration, in milliseconds, between two mouse button clicks that will be considered a double click by the underlying operating system.
      Returns:
      the double click time
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getFocusControl

      public Control getFocusControl()
      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.
      Returns:
      the focus control or null
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getHighContrast

      public boolean getHighContrast()
      Returns true when the high contrast mode is enabled. Otherwise, false is returned.

      Note: This operation is a hint and is not supported on platforms that do not have this concept.

      Returns:
      the high contrast mode
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0

    • getDepth

      public int getDepth()
      Description copied from class: Device
      Returns the bit depth of the screen, which is the number of bits it takes to represent the number of unique colors that the screen is currently capable of displaying. This number will typically be one of 1, 8, 15, 16, 24 or 32.
      Overrides:
      getDepth in class Device
      Returns:
      the depth of the screen

    • getIconDepth

      public int getIconDepth()
      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.
      Returns:
      the maximum icon depth
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • getIconSizes

      public Point[] getIconSizes()
      Returns an array containing the recommended icon sizes.
      Returns:
      the array of icon sizes
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0
      See Also:

    • isSystemDarkTheme

      public static boolean isSystemDarkTheme()
      Returns true 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.

      Returns:
      true if the current OS theme has a dark appearance, else returns false.
      Since:
      3.112

    • getLastEventTime

      int getLastEventTime()

    • getModalDialog

      Dialog getModalDialog()

    • getWorkArea

      Rectangle getWorkArea()
      Returns the work area, an EWMH property to store the size and position of the screen not covered by dock and panel windows. See http://freedesktop.org/Standards/wm-spec.

    • getMonitors

      public Monitor[] getMonitors()
      Returns an array of monitors attached to the device.
      Returns:
      the array of monitors
      Since:
      3.0

    • getPrimaryMonitor

      public Monitor getPrimaryMonitor()
      Returns the primary monitor for that device.
      Returns:
      the primary monitor
      Since:
      3.0

    • getShells

      public Shell[] getShells()
      Returns a (possibly empty) array containing all shells which have not been disposed and have the receiver as their display.
      Returns:
      the receiver's shells
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getSynchronizer

      public Synchronizer getSynchronizer()
      Gets the synchronizer used by the display.
      Returns:
      the receiver's synchronizer
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.4

    • getSyncThread

      public Thread getSyncThread()
      Returns the thread that has invoked 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.

      Returns:
      the receiver's sync-interface thread
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getSystemColor

      public Color getSystemColor(int id)
      Returns the matching standard color for the given constant, which should be one of the color constants specified in class SWT. 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.
      Overrides:
      getSystemColor in class Device
      Parameters:
      id - the color constant
      Returns:
      the matching color
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • getSystemCursor

      public Cursor getSystemCursor(int id)
      Returns the matching standard platform cursor for the given constant, which should be one of the cursor constants specified in class 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.
      Parameters:
      id - the SWT cursor constant
      Returns:
      the corresponding cursor or null
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0
      See Also:

    • getSystemImage

      public Image getSystemImage(int id)
      Returns the matching standard platform image for the given constant, which should be one of the icon constants specified in class SWT. 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.
      Parameters:
      id - the SWT icon constant
      Returns:
      the corresponding image or null
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0
      See Also:

    • getSystemMenu

      public Menu getSystemMenu()
      Returns the single instance of the system-provided menu for the application, or null on platforms where no menu is provided for the application.
      Returns:
      the system menu, or null
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.7

    • toGdkRGBA

      GdkRGBA toGdkRGBA(GdkRGBA rgba, double brightness)
      This method converts from RGB to HSV, from HSV to HSL (including brightness), from HSL back to HSV and from HSV back to RGB. In short (ordered 1 - 5): 1. RGB -> HSV 2. HSV -> HSL 3. HSL -> HSL (with brightness) 4. HSL -> HSV 5. HSV -> RGB NOTE: hue, saturation, and luminosity are values from 0 to 1. Brightness can be any number from 0 to Double.MAX_VALUE, but is only practical when luminosity and saturation are invalid input: '<'= 1. The higher the brightness, the lighter a color gets. Lighter here means "more white", i.e. saturation and luminosity values of 1.0 means the color is pure white. More info on the conversion can be found here: https://en.wikipedia.org/wiki/HSL_and_HSV http://codeitdown.com/hsl-hsb-hsv-color/
      Parameters:
      rgba - the source GdkRGBA from which RGB values are copied from
      brightness - a value between 0 and Double.MAX_VALUE which modifies the brightness of saturation and luminosity
      Returns:
      GdkRGBA object with calculated RGB values

    • inversePremultipliedColor

      static int inversePremultipliedColor(int color, int alpha)
      Calculates original color from RGBA with premultiplied alpha. NOTE: Calculating inverse gives a range of possible colors due to rounding that occurs with integer calculations. However, alpha-blend formula only has the multiplied component, so all of those inverses are equivalent.

    • renderAllBackgrounds

      private static void renderAllBackgrounds(long styleContext, long cairo)
      What user sees is a combination of multiple layers. This is only important when top layer is semi-transparent.

    • styleContextEstimateBackgroundColor

      GdkRGBA styleContextEstimateBackgroundColor(long context, int state)
      Background in GTK theme can be more complex then just solid color: 1) Due to 'background-image', 'background-position', 'background-repeat', etc. Example: 'tooltip' in 'Ambiance' theme uses 'background-image'. 2) If background is semi-transparent, user actually sees a combination of layers. Example: 'tooltip' in 'HighContrast' theme has transparent label. Both problems are solved by drawing to a temporary image and getting the color of the pixel in the middle.

    • copyRGBA

      GdkRGBA copyRGBA(GdkRGBA source)

    • initializeSystemColors

      void initializeSystemColors()

    • initializeSystemColorsWidget

      void initializeSystemColorsWidget(long shellContext)

    • initializeSystemColorsList

      void initializeSystemColorsList(long shellContext)

    • initializeSystemColorsTitle

      void initializeSystemColorsTitle(long shellContext)

    • initializeSystemColorsLink

      private void initializeSystemColorsLink()

    • initializeSystemColorsTooltip

      void initializeSystemColorsTooltip()

    • initializeSystemColorsToggleButton

      void initializeSystemColorsToggleButton()

    • initializeSystemColorsDisabled

      void initializeSystemColorsDisabled()

    • styleContextGetColor

      GdkRGBA styleContextGetColor(long context, int flag)

    • getSystemTaskBar

      public TaskBar getSystemTaskBar()
      Returns the single instance of the system taskBar or null when there is no system taskBar available for the platform.
      Returns:
      the system taskBar or null
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.6

    • getSystemTray

      public Tray getSystemTray()
      Returns the single instance of the system tray or null when there is no system tray available for the platform.
      Returns:
      the system tray or null
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0

    • getThread

      public Thread getThread()
      Returns the user-interface thread for the receiver.
      Returns:
      the receiver's user-interface thread
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed

    • getTouchEnabled

      public boolean getTouchEnabled()
      Returns a boolean indicating whether a touch-aware input device is attached to the system and is ready for use.
      Returns:
      true if a touch-aware input device is detected, or false otherwise
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.7

    • getWidget

      Widget getWidget(long handle)

    • idleProc

      long idleProc(long data)

    • init

      protected void init()
      Initializes any internal resources needed by the device.

      This method is called after create.

      Overrides:
      init in class Device
      See Also:

    • initializeCallbacks

      void initializeCallbacks()

    • initializeNamedColorList

      void initializeNamedColorList()

    • initializeSubclasses

      void initializeSubclasses()

    • initializeSystemSettings

      void initializeSystemSettings()

    • initializeWidgetTable

      void initializeWidgetTable()

    • initializeSessionManager

      void initializeSessionManager()

    • extractFreeGError

      public static String extractFreeGError(long errorPtr)
      Helper method to extract GError messages. Only call if the pointer is valid (i.e. non-zero).
      Parameters:
      errorPtr - pointer to the GError
      Returns:
      a String representing the error message that was set

    • releaseSessionManager

      void releaseSessionManager()

    • internal_dispose_GC

      public void internal_dispose_GC(long hDC, GCData data)
      Invokes platform specific functionality to dispose a GC handle.

      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.

      Specified by:
      internal_dispose_GC in interface Drawable
      Specified by:
      internal_dispose_GC in class Device
      Parameters:
      hDC - the platform specific GC handle
      data - the platform specific GC data

    • internal_new_GC

      public long internal_new_GC(GCData data)
      Invokes platform specific functionality to allocate a new GC handle.

      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.

      Specified by:
      internal_new_GC in interface Drawable
      Specified by:
      internal_new_GC in class Device
      Parameters:
      data - the platform specific GC data
      Returns:
      the platform specific GC handle
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      SWTError -
      • ERROR_NO_HANDLES if a handle could not be obtained for gc creation

    • isValidThread

      boolean isValidThread()

    • map

      public Point map(Control from, Control to, Point point)
      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.

      Parameters:
      from - the source Control or null
      to - the destination Control or null
      point - to be mapped
      Returns:
      point with mapped coordinates
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the point is null
      • ERROR_INVALID_ARGUMENT - if the Control from or the Control to have been disposed
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.1.2

    • map

      public Point map(Control from, Control to, int x, int y)
      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.

      Parameters:
      from - the source Control or null
      to - the destination Control or null
      x - coordinates to be mapped
      y - coordinates to be mapped
      Returns:
      point with mapped coordinates
      Throws:
      IllegalArgumentException -
      • ERROR_INVALID_ARGUMENT - if the Control from or the Control to have been disposed
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.1.2

    • mapInPixels

      Point mapInPixels(Control from, Control to, int x, int y)

    • map

      public Rectangle map(Control from, Control to, Rectangle rectangle)
      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.

      Parameters:
      from - the source Control or null
      to - the destination Control or null
      rectangle - to be mapped
      Returns:
      rectangle with mapped coordinates
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the rectangle is null
      • ERROR_INVALID_ARGUMENT - if the Control from or the Control to have been disposed
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.1.2

    • mapInPixels

      Rectangle mapInPixels(Control from, Control to, Rectangle rectangle)

    • map

      public Rectangle map(Control from, Control to, int x, int y, int width, int height)
      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.

      Parameters:
      from - the source Control or null
      to - the destination Control or null
      x - coordinates to be mapped
      y - coordinates to be mapped
      width - coordinates to be mapped
      height - coordinates to be mapped
      Returns:
      rectangle with mapped coordinates
      Throws:
      IllegalArgumentException -
      • ERROR_INVALID_ARGUMENT - if the Control from or the Control to have been disposed
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.1.2

    • mapInPixels

      Rectangle mapInPixels(Control from, Control to, int x, int y, int width, int height)

    • mouseHoverProc

      long mouseHoverProc(long handle)

    • findFocusedWindow

      long findFocusedWindow()

    • post

      public boolean post(Event event)
      Generate a low level system event. 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:

      • (in) type KeyDown or KeyUp

      Either one of:

      • (in) character a character that corresponds to a keyboard key
      • (in) keyCode the key code of the key that was typed, as defined by the key code constants in class SWT

      Optional (on some platforms):

      • (in) stateMask the state of the keyboard modifier, as defined by the key code constants in class SWT

      MouseDown, MouseUp

      The following fields in the Event apply:

      • (in) type MouseDown or MouseUp
      • (in) button the button that is pressed or released

      MouseMove

      The following fields in the Event apply:

      • (in) type MouseMove
      • (in) x the x coordinate to move the mouse pointer to in screen coordinates
      • (in) y the y coordinate to move the mouse pointer to in screen coordinates

      MouseWheel

      The following fields in the Event apply:

      • (in) type MouseWheel
      • (in) detail either SWT.SCROLL_LINE or SWT.SCROLL_PAGE
      • (in) count the number of lines or pages to scroll
      Parameters:
      event - the event to be generated
      Returns:
      true if the event was generated or false otherwise
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the event is null
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      3.0

    • postEvent

      void postEvent(Event event)

    • putGdkEvents

      void putGdkEvents()

    • readAndDispatch

      public boolean readAndDispatch()
      Reads an event from the operating system's event queue, dispatches it appropriately, and returns 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.

      Returns:
      false if the caller can sleep upon return from this method
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      • ERROR_FAILED_EXEC - if an exception occurred while running an inter-thread message
      See Also:

    • register

      static void register(Display display)

    • release

      protected void release()
      Releases any internal resources back to the operating system and clears all fields except the device handle.

      Disposes all shells which are currently open on the display. After this method has been invoked, all related related shells will answer 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.

      This method is called before destroy.
      Overrides:
      release in class Device
      See Also:

    • releaseDisplay

      void releaseDisplay()

    • removeFilter

      public void removeFilter(int eventType, Listener listener)
      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 SWT.
      Parameters:
      eventType - the type of event to listen for
      listener - the listener which should no longer be notified when the event occurs
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the listener is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      Since:
      3.0
      See Also:

    • removeGdkEvent

      long removeGdkEvent()

    • removeIdleProc

      void removeIdleProc()

    • removeListener

      public void removeListener(int eventType, Listener listener)
      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 SWT.
      Parameters:
      eventType - the type of event to listen for
      listener - the listener which should no longer be notified
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the listener is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.0
      See Also:

    • removeMouseHoverTimeout

      void removeMouseHoverTimeout(long handle)

    • removePopup

      void removePopup(Menu menu)

    • removeWidget

      Widget removeWidget(long handle)

    • debugInfoForIndex

      String debugInfoForIndex(long index)

    • dpiChanged

      void dpiChanged(int newScaleFactor)

    • dumpWidgetTableInfo

      String dumpWidgetTableInfo()

    • runAsyncMessages

      boolean runAsyncMessages(boolean all)

    • runDeferredEvents

      boolean runDeferredEvents()

    • runDeferredLayouts

      boolean runDeferredLayouts()

    • runPopups

      boolean runPopups()

    • runSettings

      boolean runSettings()

    • runSkin

      boolean runSkin()

    • getAppName

      public static String getAppName()
      Returns the application name.
      Returns:
      the application name
      Since:
      3.6
      See Also:

    • getAppVersion

      public static String getAppVersion()
      Returns the application version.
      Returns:
      the application version
      Since:
      3.6
      See Also:

    • setAppName

      public static void setAppName(String name)
      Sets the application name to the argument.

      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.

      Specifying null for the name clears it.

      Parameters:
      name - the new app name or null
      See Also:

    • setAppVersion

      public static void setAppVersion(String version)
      Sets the application version to the argument.
      Parameters:
      version - the new app version
      Since:
      3.6

    • setCursorLocation

      public void setCursorLocation(int x, int y)
      Sets the location of the on-screen pointer relative to the top left corner of the screen. Note: It is typically considered bad practice for a program to move the on-screen pointer location.
      Parameters:
      x - the new x coordinate for the cursor
      y - the new y coordinate for the cursor
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.1

    • setCursorLocation

      public void setCursorLocation(Point point)
      Sets the location of the on-screen pointer relative to the top left corner of the screen. Note: It is typically considered bad practice for a program to move the on-screen pointer location.
      Parameters:
      point - new position
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_NULL_ARGUMENT - if the point is null
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      Since:
      2.0

    • setData

      public void setData(String key, Object value)
      Sets the application defined property of the receiver with the specified name to the given argument.

      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.

      Parameters:
      key - the name of the property
      value - the new value for the property
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the key is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • setData

      public void setData(Object data)
      Sets the application defined, display specific data associated with the receiver, to the argument. The display specific data is a single, unnamed field that is stored with every display.

      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.

      Parameters:
      data - the new display specific data
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • setDirectionProc

      long setDirectionProc(long widget, long direction)

    • setModalDialog

      void setModalDialog(Dialog modalDailog)

    • setModalShell

      void setModalShell(Shell shell)

    • setSynchronizer

      public void setSynchronizer(Synchronizer synchronizer)
      Sets the synchronizer used by the display to be the argument, which can not be null.
      Parameters:
      synchronizer - the new synchronizer for the display (must not be null)
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the synchronizer is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      • ERROR_FAILED_EXEC - if an exception occurred while running an inter-thread message

    • setRuntimeExceptionHandler

      public final void setRuntimeExceptionHandler(Consumer<RuntimeException> runtimeExceptionHandler)
      Sets a callback that will be invoked whenever an exception is thrown by a listener or external callback function. The application may use this to set a global exception handling policy: the most common policies are either to log and discard the exception or to re-throw the exception.

      The default SWT error handling policy is to rethrow exceptions.

      Parameters:
      runtimeExceptionHandler - new exception handler to be registered.
      Since:
      3.106

    • getRuntimeExceptionHandler

      public final Consumer<RuntimeException> getRuntimeExceptionHandler()
      Returns the current exception handler. It will receive all exceptions thrown by listeners and external callbacks in this display. If code wishes to temporarily replace the exception handler (for example, during a unit test), it is common practice to invoke this method prior to replacing the exception handler so that the old handler may be restored afterward.
      Returns:
      the current exception handler. Never null.
      Since:
      3.106

    • setErrorHandler

      public final void setErrorHandler(Consumer<Error> errorHandler)
      Sets a callback that will be invoked whenever an error is thrown by a listener or external callback function. The application may use this to set a global exception handling policy: the most common policies are either to log and discard the exception or to re-throw the exception.

      The default SWT error handling policy is to rethrow exceptions.

      Parameters:
      errorHandler - new error handler to be registered.
      Since:
      3.106

    • getErrorHandler

      public final Consumer<Error> getErrorHandler()
      Returns the current exception handler. It will receive all errors thrown by listeners and external callbacks in this display. If code wishes to temporarily replace the error handler (for example, during a unit test), it is common practice to invoke this method prior to replacing the error handler so that the old handler may be restored afterward.
      Returns:
      the current error handler. Never null.
      Since:
      3.106

    • showIMWindow

      void showIMWindow(Control control)

    • sleep

      public boolean sleep()
      Causes the user-interface thread to sleep (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.
      Returns:
      true if an event requiring dispatching was placed on the queue.
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • timerExec

      public void timerExec(int milliseconds, Runnable 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.

      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.

      Parameters:
      milliseconds - the delay before running the runnable
      runnable - code to run on the user-interface thread
      Throws:
      IllegalArgumentException -
      • ERROR_NULL_ARGUMENT - if the runnable is null
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • timerProc

      long timerProc(long i)

    • caretProc

      long caretProc(long clientData)

    • resetCaretTiming

      void resetCaretTiming()

    • sizeAllocateProc

      long sizeAllocateProc(long handle, long arg0, long user_data)

    • sizeRequestProc

      long sizeRequestProc(long handle, long arg0, long user_data)

    • saveResources

      void saveResources()

    • sendJDKInternalEvent

      private void sendJDKInternalEvent(int eventType)

    • sendJDKInternalEvent

      private void sendJDKInternalEvent(int eventType, int detail)
      does sent event with JDK time

    • sendEvent

      void sendEvent(int eventType, Event event)

    • sendEvent

      void sendEvent(EventTable eventTable, Event event)

    • sendPreEvent

      void sendPreEvent(int eventType)

    • sendPostEvent

      void sendPostEvent(int eventType)

    • sendPreExternalEventDispatchEvent

      public void sendPreExternalEventDispatchEvent()
      Sends a SWT.PreExternalEventDispatch event.

    • sendPostExternalEventDispatchEvent

      public void sendPostExternalEventDispatchEvent()
      Sends a SWT.PostExternalEventDispatch event.

    • setCurrentCaret

      void setCurrentCaret(Caret caret)

    • shellMapProc

      long shellMapProc(long handle, long arg0, long user_data)

    • signalProc

      long signalProc(long gobject, long arg1, long user_data)

    • syncExec

      public void syncExec(Runnable runnable)
      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.

      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.

      Parameters:
      runnable - code to run on the user-interface thread or null
      Throws:
      SWTException -
      • ERROR_FAILED_EXEC - if an exception occurred when executing the runnable
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • syncCall

      public <T, E extends Exception> T syncCall(SwtCallable<T,E> callable) throws E
      Calls the callable on the user-interface thread at the next reasonable opportunity, and returns the its result from this method. The thread which calls this method is suspended until the callable completes.

      Note that at the time the callable 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 callable before accessing the widget.

      Any exception that is thrown from the callable is re-thrown in the calling thread. Note: The exception retains its original stack trace from the throwing thread. The call to syncCall will not be present in the stack trace.

      Parameters:
      callable - the code to call on the user-interface thread
      Throws:
      SWTException - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      E - An exception that is thrown by the callable on the user-interface thread, and re-thrown on the calling thread
      Since:
      3.118
      See Also:

    • translateKey

      static int translateKey(int key)

    • untranslateKey

      static int untranslateKey(int key)

    • update

      public void update()
      Forces all outstanding paint requests for the display to be processed before this method returns.
      Throws:
      SWTException -
      • ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • wake

      public void wake()
      If the receiver's user-interface thread was sleeping, causes it to be awakened and start running again. Note that this method may be called from any thread.
      Throws:
      SWTException -
      • ERROR_DEVICE_DISPOSED - if the receiver has been disposed
      See Also:

    • wakeThread

      void wakeThread()

    • enterMotionProc

      void enterMotionProc(long controller, double x, double y, long user_data)

    • scrollProc

      boolean scrollProc(long controller, double dx, double dy, long user_data)

    • focusProc

      void focusProc(long controller, long user_data)

    • windowActiveProc

      void windowActiveProc(long handle, long user_data)

    • keyPressReleaseProc

      boolean keyPressReleaseProc(long controller, int keyval, int keycode, int state, long user_data)

    • gesturePressReleaseProc

      void gesturePressReleaseProc(long gesture, int n_press, double x, double y, long user_data)

    • leaveProc

      void leaveProc(long controller, long user_data)

    • computeSizeProc

      void computeSizeProc(long toplevel, long size, long user_data)

    • activateProc

      void activateProc(long action, long parameter, long user_data)

    • resizeProc

      void resizeProc(long handle, int width, int height)

    • notifyProc

      long notifyProc(long object, long param_spec, long user_data)

    • changeValue

      boolean changeValue(long handle, int scroll, double value, long user_data)

    • windowProc

      long windowProc(long handle, long user_data)

    • windowProc

      long windowProc(long handle, long arg0, long user_data)

    • windowProc

      long windowProc(long handle, long arg0, long arg1, long user_data)

    • windowProc

      long windowProc(long handle, long arg0, long arg1, long arg2, long user_data)

    • windowProc

      long windowProc(long handle, long arg0, long arg1, long arg2, long arg3, long user_data)

    • windowTimerProc

      long windowTimerProc(long handle)

    • getWindowPointerPosition

      long getWindowPointerPosition(long window, int[] x, int[] y, int[] mask)
      Gets the current cursor position relative to the upper left corner of the window. Available to GTK3 implementations only.
      Returns:
      the cursor position to x invalid input: '&' y. Return value of the function is the window pointer underneath the cursor, can be NULL.

    • getPointerPosition

      void getPointerPosition(double[] x, double[] y)
      Gets the current cursor position relative to the upper left corner of the surface. Available to GTK4 implementations only.

    • gdk_device_get_window_at_position

      long gdk_device_get_window_at_position(int[] win_x, int[] win_y)

    • gdk_device_get_surface_at_position

      long gdk_device_get_surface_at_position(double[] win_x, double[] win_y)

    • _getDeviceZoom

      static int _getDeviceZoom(long monitor_num)

    • isActivateShellOnForceFocus

      static boolean isActivateShellOnForceFocus()

    • isRescalingAtRuntime

      public boolean isRescalingAtRuntime()
      Returns whether rescaling of shells at runtime when the DPI scaling of a shell's monitor changes is activated for this device.

      Note: This functionality is only available on Windows. Calling this method on other operating system will always return false.

      Returns:
      whether rescaling of shells at runtime when the DPI scaling of a shell's monitor changes is activated for this device
      Since:
      3.127

    • setRescalingAtRuntime

      @Deprecated(since="2025-03", forRemoval=true) public boolean setRescalingAtRuntime(boolean activate)
      Deprecated, for removal: This API element is subject to removal in a future version.
      this method should not be used as it needs to be called already during instantiation to take proper effect
      Activates or deactivates rescaling of shells at runtime whenever the DPI scaling of the shell's monitor changes. This is only safe to call as long as no shell has been created for this display. When changing the value after a shell has been created for this display, the effect is undefined.

      Note: This functionality is only available on Windows. Calling this method on other operating system will have no effect.

      Parameters:
      activate - whether rescaling shall be activated or deactivated
      Returns:
      whether activating or deactivating the rescaling was successful
      Since:
      3.127