org.eclipse.swt.graphics.Device Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.eclipse.swt.gtk.linux.aarch64 Show documentation
Show all versions of org.eclipse.swt.gtk.linux.aarch64 Show documentation
Standard Widget Toolkit for GTK on aarch64
The newest version!
/*******************************************************************************
* Copyright (c) 2000, 2018 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.swt.graphics;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
import org.eclipse.swt.*;
import org.eclipse.swt.internal.*;
import org.eclipse.swt.internal.gtk.*;
import org.eclipse.swt.internal.gtk3.*;
import org.eclipse.swt.internal.gtk4.*;
/**
* This class is the abstract superclass of all device objects,
* such as the Display device and the Printer device. Devices
* can have a graphics context (GC) created for them, and they
* can be drawn on by sending messages to the associated GC.
*
* @see Sample code and further information
*/
public abstract class Device implements Drawable {
/**
* @noreference This field is not intended to be referenced by clients.
* @since 3.105
*/
protected static final int CHANGE_SCALEFACTOR = 1;
/* Settings callbacks */
long gsettingsProc;
Callback gsettingsCallback;
boolean isConnected = false;
long displaySettings; //gsettings Dictionary
/**
* the handle to the X Display
* (Warning: This field is platform dependent)
*
* IMPORTANT: This field is not part of the SWT
* public API. It is marked protected only so that it can be shared
* within the packages provided by SWT. It is not available on all
* platforms and should never be accessed from application code.
*
*
* @noreference This field is not intended to be referenced by clients.
*/
protected long xDisplay;
long shellHandle;
/* Debugging */
public static boolean DEBUG;
boolean debug = DEBUG;
boolean tracking = DEBUG;
Error [] errors;
Object [] objects;
Object trackingLock;
/* Disposed flag */
volatile boolean disposed;
/* Warning and Error Handlers */
long logProc;
Callback logCallback;
//NOT DONE - get list of valid names
String [] log_domains = {"", "GLib-GObject", "GLib", "GObject", "Pango", "ATK", "GdkPixbuf", "Gdk", "Gtk", "GnomeVFS", "GIO"};
int [] handler_ids = new int [log_domains.length];
int warningLevel;
/* X Warning and Error Handlers */
static Callback XErrorCallback, XIOErrorCallback;
static long XErrorProc, XIOErrorProc, XNullErrorProc, XNullIOErrorProc;
static Device[] Devices = new Device[4];
/*
* The following colors are listed in the Windows
* Programmer's Reference as the colors in the default
* palette.
*/
Color COLOR_BLACK, COLOR_DARK_RED, COLOR_DARK_GREEN, COLOR_DARK_YELLOW, COLOR_DARK_BLUE;
Color COLOR_DARK_MAGENTA, COLOR_DARK_CYAN, COLOR_GRAY, COLOR_DARK_GRAY, COLOR_RED, COLOR_TRANSPARENT;
Color COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE;
/* System Font */
Font systemFont;
/* Device dpi */
Point dpi;
long emptyTab;
/*
* TEMPORARY CODE. When a graphics object is
* created and the device parameter is null,
* the current Display is used. This presents
* a problem because SWT graphics does not
* reference classes in SWT widgets. The correct
* fix is to remove this feature. Unfortunately,
* too many application programs rely on this
* feature.
*/
protected static Device CurrentDevice;
protected static Runnable DeviceFinder;
static {
try {
Class.forName ("org.eclipse.swt.widgets.Display");
} catch (ClassNotFoundException e) {}
}
/*
* TEMPORARY CODE.
*/
static synchronized Device getDevice () {
if (DeviceFinder != null) DeviceFinder.run();
Device device = CurrentDevice;
CurrentDevice = null;
return device;
}
/**
* Constructs a new instance of this class.
*
* You must dispose the device when it is no longer required.
*
*
* @see #create
* @see #init
*
* @since 3.1
*/
public Device() {
this(null);
}
/**
* Constructs a new instance of this class.
*
* You must dispose the device when it is no longer required.
*
*
* @param data the DeviceData which describes the receiver
*
* @see #create
* @see #init
* @see DeviceData
*/
public Device(DeviceData data) {
synchronized (Device.class) {
if (data != null) {
debug = data.debug;
tracking = data.tracking;
}
if (tracking) {
startTracking();
}
create (data);
init ();
register (this);
}
}
/**
*
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
* @since 3.115
*/
public boolean isTracking() {
checkDevice();
return tracking;
}
/**
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
* @since 3.115
*/
public void setTracking(boolean tracking) {
checkDevice();
if (tracking == this.tracking) {
return;
}
this.tracking = tracking;
if (tracking) {
startTracking();
} else {
stopTracking();
}
}
private void startTracking() {
errors = new Error [128];
objects = new Object [128];
trackingLock = new Object ();
}
private void stopTracking() {
synchronized (trackingLock) {
objects = null;
errors = null;
trackingLock = null;
}
}
/**
* 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.
*
*
* @exception SWTException
* - ERROR_WIDGET_DISPOSED - if the receiver has been disposed
*
*/
protected void checkDevice () {
if (disposed) SWT.error(SWT.ERROR_DEVICE_DISPOSED);
}
/**
* 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.
*
* Subclasses are supposed to reimplement this method and not
* call the super implementation.
*
*
* @param data the DeviceData which describes the receiver
*
* @see #init
*/
protected void create (DeviceData data) {
}
/**
* Disposes of the operating system resources associated with
* the receiver. After this method has been invoked, the receiver
* will answer true when sent the message
* isDisposed().
*
* @see #release
* @see #destroy
* @see #checkDevice
*/
public void dispose () {
synchronized (Device.class) {
try (ExceptionStash exceptions = new ExceptionStash ()) {
if (isDisposed ()) return;
checkDevice ();
try {
release ();
} catch (Error | RuntimeException ex) {
exceptions.stash (ex);
}
destroy ();
deregister (this);
xDisplay = 0;
disposed = true;
if (tracking) {
tracking = false;
stopTracking ();
}
}
}
}
void dispose_Object (Object object) {
synchronized (trackingLock) {
for (int i=0; i
* This method is called after release.
*
* Subclasses are supposed to reimplement this method and not
* call the super implementation.
*
*
* @see #dispose
* @see #release
*/
protected void destroy () {
}
/**
* Returns a rectangle describing the receiver's size and location.
*
* @return the bounding rectangle
*
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
*/
public Rectangle getBounds () {
checkDevice ();
return DPIUtil.autoScaleDown (getBoundsInPixels ());
}
private Rectangle getBoundsInPixels () {
return new Rectangle(0, 0, 0, 0);
}
/**
* Returns a DeviceData based on the receiver.
* Modifications made to this DeviceData will not
* affect the receiver.
*
* @return a DeviceData containing the device's data and attributes
*
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
*
* @see DeviceData
*/
public DeviceData getDeviceData () {
checkDevice();
DeviceData data = new DeviceData ();
data.debug = debug;
data.tracking = tracking;
if (tracking) {
synchronized (trackingLock) {
int count = 0, length = objects.length;
for (int i=0; i
* ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
*
* @see #getBounds
*/
public Rectangle getClientArea () {
return getBounds ();
}
/**
* 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.
*
* @return the depth of the screen
*
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
*/
public int getDepth () {
checkDevice ();
return 0;
}
/**
* Returns a point whose x coordinate is the logical horizontal
* dots per inch of the display, and whose y coordinate
* is the logical vertical dots per inch of the display.
*
* @return the horizontal and vertical DPI
*
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
*/
public Point getDPI () {
checkDevice ();
return getScreenDPI();
}
/**
* Returns FontData objects which describe
* the fonts that match the given arguments. If the
* faceName is null, all fonts will be returned.
*
* @param faceName the name of the font to look for, or null
* @param scalable if true only scalable fonts are returned, otherwise only non-scalable fonts are returned.
* @return the matching font data
*
* @exception SWTException
* - ERROR_DEVICE_DISPOSED - if the receiver has been disposed
*
*/
public FontData[] getFontList (String faceName, boolean scalable) {
checkDevice ();
if (!scalable) return new FontData[0];
long [] family = new long [1];
long [] face = new long [1];
long [] families = new long [1];
int[] n_families = new int[1];
long [] faces = new long [1];
int[] n_faces = new int[1];
long context;
if (GTK.GTK4) {
long fontMap = OS.pango_cairo_font_map_get_default ();
context = OS.pango_font_map_create_context (fontMap);
} else {
context = GDK.gdk_pango_context_get();
}
OS.pango_context_list_families(context, families, n_families);
int nFds = 0;
FontData[] fds = new FontData[faceName != null ? 4 : n_families[0]];
for (int i=0; iSWT . 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 freed because it was allocated by the system,
* not the application.
*
* @param id the color constant
* @return the matching color
*
* @exception SWTException -
*
- ERROR_DEVICE_DISPOSED - if the receiver has been disposed *
* Typically, applications which want the default look * should simply not set the font on the widgets they * create. Widgets are always created with the correct * default font for the class of user-interface component * they represent. *
* * @return a font * * @exception SWTException-
*
- ERROR_DEVICE_DISPOSED - if the receiver has been disposed *
true if the underlying window system prints out
* warning messages on the console, and setWarnings
* had previously been called with true.
*
* @return trueif warnings are being handled, and false otherwise
*
* @exception SWTException -
*
- ERROR_DEVICE_DISPOSED - if the receiver has been disposed *
* This method is called after create.
*
* If subclasses reimplement this method, they must
* call the super implementation.
*
* IMPORTANT: This method is not part of the public
* API for Device. 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.
*
* IMPORTANT: This method is not part of the public
* API for Device. 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.
*
true if the device has been disposed,
* and false otherwise.
*
* This method gets the dispose state for the device.
* When a device has been disposed, it is an error to
* invoke any other method using the device.
*
* @return true when the device is disposed and false otherwise
*/
public boolean isDisposed () {
return disposed;
}
/**
* Loads the font specified by a file. The font will be
* present in the list of fonts available to the application.
*
* @param path the font file path
* @return whether the font was successfully loaded
*
* @exception SWTException
-
*
- ERROR_NULL_ARGUMENT - if path is null *
- ERROR_DEVICE_DISPOSED - if the receiver has been disposed *
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.
*
* If subclasses reimplement this method, they must
* call the super implementation.
*
true then
* message printing is not blocked.
*
* @param warnings trueif warnings should be printed, and false otherwise
*
* @exception SWTException -
*
- ERROR_DEVICE_DISPOSED - if the receiver has been disposed *