From d2386fa0e3cc5e80fcfe51f07751d13676655d76 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Thu, 21 Jul 2022 12:45:26 +0200 Subject: Improve makefile, change license to ISC, change code style, remove dist/ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libgamma/AdjustmentMethod.java | 228 ++++++++++++ libgamma/AdjustmentMethodCapabilities.java | 147 ++++++++ libgamma/CRTC.java | 285 +++++++++++++++ libgamma/CRTCInformation.java | 552 +++++++++++++++++++++++++++++ libgamma/ConnectorType.java | 148 ++++++++ libgamma/GammaRamps.java | 312 ++++++++++++++++ libgamma/Libgamma.java | 30 ++ libgamma/LibgammaException.java | 411 +++++++++++++++++++++ libgamma/Partition.java | 125 +++++++ libgamma/Ramp.java | 160 +++++++++ libgamma/Ramp16.java | 79 +++++ libgamma/Ramp32.java | 57 +++ libgamma/Ramp64.java | 44 +++ libgamma/Ramp8.java | 83 +++++ libgamma/Rampd.java | 66 ++++ libgamma/Rampf.java | 57 +++ libgamma/Site.java | 133 +++++++ libgamma/SubpixelOrder.java | 77 ++++ 18 files changed, 2994 insertions(+) create mode 100644 libgamma/AdjustmentMethod.java create mode 100644 libgamma/AdjustmentMethodCapabilities.java create mode 100644 libgamma/CRTC.java create mode 100644 libgamma/CRTCInformation.java create mode 100644 libgamma/ConnectorType.java create mode 100644 libgamma/GammaRamps.java create mode 100644 libgamma/Libgamma.java create mode 100644 libgamma/LibgammaException.java create mode 100644 libgamma/Partition.java create mode 100644 libgamma/Ramp.java create mode 100644 libgamma/Ramp16.java create mode 100644 libgamma/Ramp32.java create mode 100644 libgamma/Ramp64.java create mode 100644 libgamma/Ramp8.java create mode 100644 libgamma/Rampd.java create mode 100644 libgamma/Rampf.java create mode 100644 libgamma/Site.java create mode 100644 libgamma/SubpixelOrder.java (limited to 'libgamma') diff --git a/libgamma/AdjustmentMethod.java b/libgamma/AdjustmentMethod.java new file mode 100644 index 0000000..7d53090 --- /dev/null +++ b/libgamma/AdjustmentMethod.java @@ -0,0 +1,228 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Class of adjustment methods + */ +public enum AdjustmentMethod +{ + /** + * The identifier for the dummy adjustment method. + * This method can be configured and is useful for + * testing your program's ability to handle errors. + */ + DUMMY(0), + + /** + * The identifier for the adjustment method with + * uses the RandR protocol under the X display server + */ + X_RANDR(1), + + /** + * The identifier for the adjustment method with + * uses the VidMode protocol under the X display server. + * This is an older alternative to RandR that can + * work on some drivers that are not supported by RandR, + * however it can only control the primary CRTC per + * screen (partition). + */ + X_VIDMODE(2), + + /** + * The identifier for the Direct Rendering Manager + * adjustment method that is available in Linux + * (built in to the Linux kernel with a userland + * library for access) and is a part of the + * Direct Rendering Infrastructure. This adjustment + * method all work when you are in non-graphical + * mode; however a display server cannnot be + * started while this is running, but it can be + * started while a display server is running. + */ + LINUX_DRM(3), + + /** + * The identifier for the Graphics Device Interface + * adjustment method that is available in Windows. + * This method is not well tested; it can be compiled + * to be available under X.org using a translation layer. + */ + W32_GDI(4), + + /** + * The identifier for the CoreGraphics adjustment + * method that is available in Mac OS X that can + * adjust gamma ramps under the Quartz display server. + * This method is not well tested; it can be compiled + * to be available under X.org using a translation layer. + */ + QUARTZ_CORE_GRAPHICS(5); + + + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * The index of the last gamma method, neither it + * nor any index before it may actually be supported + * as it could have been disabled at compile-time + */ + public static final int MAX = 5; + + /** + * The number adjustment methods provided by this library. + * Note however that this includes adjstment methods that + * have been removed at compile-time + */ + public static final int COUNT = MAX + 1; + + /** + * Adjustment methods by their numerical values + */ + public static AdjustmentMethod[] VALUES = + { + DUMMY, X_RANDR, X_VIDMODE, LINUX_DRM, W32_GDI, QUARTZ_CORE_GRAPHICS + }; + + + /** + * Constructor + * + * @param value The numerical value of the adjustment method + */ + private AdjustmentMethod(int value) + { + this.value = value; + } + + + /** + * The numerical value of the adjustment method + */ + public final int value; + + + /** + * Check whether the adjustment method is available + * + * @return Whether the adjustment method is available + */ + public boolean is_available() + { + return libgamma_is_method_available(this.value) != 0; + } + + /** + * Get the default site for the adjustment method + * + * @return The default site for the adjustment method + */ + public String get_default_site() + { + return libgamma_method_default_site(this.value); + } + + /** + * Get the default variable that determines the default + * site for the adjustment method + * + * @return default variable that determines the default + * site for the adjustment method + */ + public String get_default_site_variable() + { + return libgamma_method_default_site_variable(this.value); + } + + /** + * Return the capabilities of the adjustment method + * + * @return The capabilities of the adjustment method + */ + public AdjustmentMethodCapabilities get_capabilities() + { + return new AdjustmentMethodCapabilities(libgamma_method_capabilities(this.value)); + } + + + /** + * List available adjustment methods by their order of preference based on the environment + * + * @param operation Allowed values:
+ * 0: Methods that the environment suggests will work, excluding fake
+ * 1: Methods that the environment suggests will work, including fake
+ * 2: All real non-fake methods
+ * 3: All real methods
+ * 4: All methods
+ * Other values invoke undefined behaviour + * @return List available adjustment methods by their order of preference + */ + public static AdjustmentMethod[] list_methods(int operation) + { + int[] methods = libgamma_list_methods(operation); + AdjustmentMethod[] rc = new AdjustmentMethod[methods.length]; + for (int i = 0; i < methods.length; i++) + rc[i] = VALUES[methods[i]]; + return rc; + } + + + /** + * List available adjustment methods by their order of preference based on the environment + * + * @param operation Allowed values:
+ * 0: Methods that the environment suggests will work, excluding fake
+ * 1: Methods that the environment suggests will work, including fake
+ * 2: All real non-fake methods
+ * 3: All real methods
+ * 4: All methods
+ * Other values invoke undefined behaviour + * @return List available adjustment methods by their order of preference + */ + private static native int[] libgamma_list_methods(int operation); + + /** + * Check whether an adjustment method is available, non-existing (invalid) methods will + * be identified as not available under the rationale that the library may be out of date + * + * @param method The adjustment method + * @return Whether the adjustment method is available + */ + private static native int libgamma_is_method_available(int method); + + /** + * Return the capabilities of an adjustment method + * + * @param method The adjustment method (display server and protocol) + * @return Input parameter to the constructor of {@link AdjustmentMethodCapabilities} + */ + private static native long libgamma_method_capabilities(int method); + + /** + * Return the default site for an adjustment method + * + * @param method The adjustment method (display server and protocol) + * @return The default site, {@code null} if it cannot be determined or + * if multiple sites are not supported by the adjustment method + */ + private static native String libgamma_method_default_site(int method); + + /** + * Return the default variable that determines + * the default site for an adjustment method + * + * @param method The adjustment method (display server and protocol) + * @return The environ variables that is used to determine the + * default site; {@code null} if there is none, that is, + * if the method does not support multiple sites + */ + private static native String libgamma_method_default_site_variable(int method); +} diff --git a/libgamma/AdjustmentMethodCapabilities.java b/libgamma/AdjustmentMethodCapabilities.java new file mode 100644 index 0000000..871813f --- /dev/null +++ b/libgamma/AdjustmentMethodCapabilities.java @@ -0,0 +1,147 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Capabilities of adjustment methods + */ +public class AdjustmentMethodCapabilities +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param data Low half: the value of {@link #crtc_information}
+ * High half: the values of the booleanic variables + */ + AdjustmentMethodCapabilities(long data) + { + this.crtc_information = (int)data; + + this.default_site_known = (data & (1L << 33L)) != 0; + this.multiple_sites = (data & (1L << 34L)) != 0; + this.multiple_partitions = (data & (1L << 35L)) != 0; + this.multiple_crtcs = (data & (1L << 36L)) != 0; + this.partitions_are_graphics_cards = (data & (1L << 37L)) != 0; + this.site_restore = (data & (1L << 38L)) != 0; + this.partition_restore = (data & (1L << 39L)) != 0; + this.crtc_restore = (data & (1L << 40L)) != 0; + this.identical_gamma_sizes = (data & (1L << 41L)) != 0; + this.fixed_gamma_size = (data & (1L << 42L)) != 0; + this.fixed_gamma_depth = (data & (1L << 43L)) != 0; + this.real = (data & (1L << 44L)) != 0; + this.fake = (data & (1L << 45L)) != 0; + } + + + /** + * OR of the CRTC information fields in {@link CRTCInformation} + * that may (but can fail) be read successfully + */ + public int crtc_information; + + /** + * Whether the default site is known, if true the site is integrated + * to the system or can be determined using environment variables + */ + public boolean default_site_known; + + /** + * Whether the adjustment method supports multiple sites rather + * than just the default site + */ + public boolean multiple_sites; + + /** + * Whether the adjustment method supports multiple partitions + * per site + */ + public boolean multiple_partitions; + + /** + * Whether the adjustment method supports multiple CRTC:s + * per partition per site + */ + public boolean multiple_crtcs; + + /** + * Whether the partition to graphics card is a bijection + */ + public boolean partitions_are_graphics_cards; + + /** + * Whether the adjustment method supports {@link Site#restore} + */ + public boolean site_restore; + + /** + * Whether the adjustment method supports {@link Partition#restore} + */ + public boolean partition_restore; + + /** + * Whether the adjustment method supports {@link CRTC#restore} + */ + public boolean crtc_restore; + + /** + * Whether the {@link #red_gamma_size}, {@link #green_gamma_size} and + * {@link #blue_gamma_size} fields in {@link CRTCInformation} will + * always have the same values as each other for the adjustment method + */ + public boolean identical_gamma_sizes; + + /** + * Whether the {@link #red_gamma_size}, {@link #green_gamma_size} and + * {@link #blue_gamma_size} fields in {@link CRTCInformation} will + * always be filled with the same value for the adjustment method + */ + public boolean fixed_gamma_size; + + /** + * Whether the {@link #gamma_depth} field in {@link CRTCInformation} + * will always be filled with the same value for the adjustment method + */ + public boolean fixed_gamma_depth; + + /** + * Whether the adjustment method will actually perform adjustments + */ + public boolean real; + + /** + * Whether the adjustment method is implement using a translation layer + */ + public boolean fake; + + + /** + * {@inheritDoc} + */ + public String toString() + { + return ""; + } +} diff --git a/libgamma/CRTC.java b/libgamma/CRTC.java new file mode 100644 index 0000000..de4abdb --- /dev/null +++ b/libgamma/CRTC.java @@ -0,0 +1,285 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Cathode ray tube controller state + *

+ * The CRTC controls the gamma ramps for the + * monitor that is plugged in to the connector + * that the CRTC belongs to + */ +public class CRTC +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param partition The partition this CRTC belongs to + * @param crtc The index of the CRTC within its partition + */ + public CRTC(Partition partition, int crtc) throws LibgammaException + { + this.partition = partition; + this.crtc = crtc; + long[] r = libgamma_crtc_create(partition.address, crtc); + this.address = r[0]; + if (r[1] != 0) + throw new LibgammaException((int)(r[1])); + } + + + /** + * The partition this CRTC belongs to + */ + public final Partition partition; + + /** + * The index of the CRTC within its partition + */ + public final int crtc; + + /** + * The address of the native object + */ + final long address; + + + /** + * Release resources + */ + public void close() + { + libgamma_crtc_free(this.address); + } + + /** + * Restore the gamma ramps for the CRTC to the system settings + */ + public void restore() throws LibgammaException + { + int r = libgamma_crtc_restore(this.address); + if (r != 0) + throw new LibgammaException(r); + } + + /** + * Read information about the CRTC + * + * @param fields OR:ed identifiers for the information about the CRTC that should be read + * @return Information about the CRTC + */ + public CRTCInformation get_information(int fields) + { + Object[] r = libgamma_get_crtc_information(this.address, fields); + byte[] edid = (byte[])(r[0]); + String connector_name = (String)(r[1]); + float[] gamma = (float[])(r[2]); + int[] ints = (int[])(r[3]); + return new CRTCInformation(edid, connector_name, gamma, ints); + } + + /** + * Get the current gamma ramps for the CRTC + * + * @param output The gamma ramp structure to fill + */ + public void get_gamma(GammaRamps output) throws LibgammaException + { + int r = 0; + if (output.depth == 8) r = libgamma_crtc_get_gamma_ramps8(this.address, output.address); + else if (output.depth == 16) r = libgamma_crtc_get_gamma_ramps16(this.address, output.address); + else if (output.depth == 32) r = libgamma_crtc_get_gamma_ramps32(this.address, output.address); + else if (output.depth == 64) r = libgamma_crtc_get_gamma_ramps64(this.address, output.address); + else if (output.depth == -1) r = libgamma_crtc_get_gamma_rampsf(this.address, output.address); + else if (output.depth == -2) r = libgamma_crtc_get_gamma_rampsd(this.address, output.address); + if (r != 0) + throw new LibgammaException(r); + } + + /** + * Set the gamma ramps for the CRTC + * + * @param values The gamma ramps to apply + */ + public void set_gamma(GammaRamps values) throws LibgammaException + { + int r = 0; + if (values.depth == 8) r = libgamma_crtc_set_gamma_ramps8(this.address, values.address); + else if (values.depth == 16) r = libgamma_crtc_set_gamma_ramps16(this.address, values.address); + else if (values.depth == 32) r = libgamma_crtc_set_gamma_ramps32(this.address, values.address); + else if (values.depth == 64) r = libgamma_crtc_set_gamma_ramps64(this.address, values.address); + else if (values.depth == -1) r = libgamma_crtc_set_gamma_rampsf(this.address, values.address); + else if (values.depth == -2) r = libgamma_crtc_set_gamma_rampsd(this.address, values.address); + if (r != 0) + throw new LibgammaException(r); + } + + + /** + * {@inheritDoc} + */ + public String toString() + { + return ""; + } + + + /** + * Create a CRTC state + * + * @param partition The partition state for the partition that the CRTC belongs to + * @param crtc The index of the CRTC within the partition + * @return Element 0: The value for {@link #address}
+ * Element 1: Error code, zero on success + */ + private static native long[] libgamma_crtc_create(long partition, int crtc); + + /** + * Release all resources held by a CRTC state + * and free the CRTC state pointer + * + * @param address The CRTC state + */ + private static native void libgamma_crtc_free(long address); + + /** + * Restore the gamma ramps for a CRTC to the system settings for that CRTC + * + * @param address The CRTC state + * @return Zero on success, and error code on failure + */ + private static native int libgamma_crtc_restore(long address); + + /** + * Read information about a CRTC + * + * @param crtc The state of the CRTC whose information should be read + * @param fields OR:ed identifiers for the information about the CRTC that should be read + * @return Input parameters for the constructor of {@link CRTCInformation} + */ + private static native Object[] libgamma_get_crtc_information(long crtc, int fields); + + + /** + * Get the current gamma ramps for a CRTC, 8-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to fill with the current values + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_get_gamma_ramps8(long address, long ramps); + + /** + * Set the gamma ramps for a CRTC, 8-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to apply + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_set_gamma_ramps8(long address, long ramps); + + + /** + * Get the current gamma ramps for a CRTC, 16-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to fill with the current values + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_get_gamma_ramps16(long address, long ramps); + + /** + * Set the gamma ramps for a CRTC, 16-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to apply + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_set_gamma_ramps16(long address, long ramps); + + + /** + * Get the current gamma ramps for a CRTC, 32-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to fill with the current values + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_get_gamma_ramps32(long address, long ramps); + + /** + * Set the gamma ramps for a CRTC, 32-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to apply + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_set_gamma_ramps32(long address, long ramps); + + + /** + * Get the current gamma ramps for a CRTC, 64-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to fill with the current values + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_get_gamma_ramps64(long address, long ramps); + + /** + * Set the gamma ramps for a CRTC, 64-bit gamma-depth version + * + * @param address The CRTC state + * @param ramps The gamma ramps to apply + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_set_gamma_ramps64(long address, long ramps); + + + /** + * Set the gamma ramps for a CRTC, single precision floating point version + * + * @param address The CRTC state + * @param ramps The gamma ramps to apply + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_set_gamma_rampsf(long address, long ramps); + + /** + * Get the current gamma ramps for a CRTC, single precision floating point version + * + * @param address The CRTC state + * @param ramps The gamma ramps to fill with the current values + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_get_gamma_rampsf(long address, long ramps); + + + /** + * Get the current gamma ramps for a CRTC, double precision floating point version + * + * @param address The CRTC state + * @param ramps The gamma ramps to fill with the current values + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_get_gamma_rampsd(long address, long ramps); + + /** + * Set the gamma ramps for a CRTC, double precision floating point version + * + * @param address The CRTC state + * @param ramps The gamma ramps to apply + * @return Zero on success, an error code on failure + */ + private static native int libgamma_crtc_set_gamma_rampsd(long address, long ramps); +} diff --git a/libgamma/CRTCInformation.java b/libgamma/CRTCInformation.java new file mode 100644 index 0000000..dc9b759 --- /dev/null +++ b/libgamma/CRTCInformation.java @@ -0,0 +1,552 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Cathode ray tube controller information data structure + */ +public class CRTCInformation +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * For a {@link CRTCInformation} fill in the values for {@link #edid} + * and {@link #edid_length} and report errors to {@link #edid_error} + */ + public static final int EDID = 1 << 0; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #width_mm} and report errors to {@link #width_mm_error} + */ + public static final int WIDTH_MM = 1 << 1; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #height_mm} and report errors to {@link #height_mm_error} + */ + public static final int HEIGHT_MM = 1 << 2; + + /** + * For a {@link CRTCInformation} fill in the value for {@link #width_mm_edid} + * and report errors to {@link #width_mm_edid_error} + */ + public static final int WIDTH_MM_EDID = 1 << 3; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #height_mm_edid} and report errors to {@link #height_mm_edid_error} + */ + public static final int HEIGHT_MM_EDID = 1 << 4; + + /** + * For a {@link CRTCInformation} fill in the values for + * {@link #red_gamma_size}, {@link #green_gamma_size} and + * {@link #blue_gamma_size}, and report errors to + * {@link #gamma_size_error} + */ + public static final int GAMMA_SIZE = 1 << 5; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #gamma_depth} and report errors to {@link #gamma_depth_error} + */ + public static final int GAMMA_DEPTH = 1 << 6; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #gamma_support} and report errors to {@link #gamma_support_error} + */ + public static final int GAMMA_SUPPORT = 1 << 7; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #subpixel_order} and report errors to {@link #subpixel_order_error} + */ + public static final int SUBPIXEL_ORDER = 1 << 8; + + /** + * For a {@link CRTCInformation} fill in the value for + * {@link #active} and report errors to {@link #active_error} + */ + public static final int ACTIVE = 1 << 9; + + /** + * For a {@link CRTCInformation} fill in the value + * for {@link #connector_name} and report errors to + * {@link #connector_name_error} + */ + public static final int CONNECTOR_NAME = 1 << 10; + + /** + * For a {@link CRTCInformation} fill in the + * value for {@link #connector_type} and report + * errors to {@link #connector_type_error} + */ + public static final int CONNECTOR_TYPE = 1 << 11; + + /** + * For a {@link CRTCInformation} fill in the values for + * {@link #gamma_red}, {@link #gamma_green} and + * {@link #gamma_blue} and report errors to {@link #gamma_error} + */ + public static final int GAMMA = 1 << 12; + + + /** + * The number of {@link #*} values defined + */ + public static final int COUNT = 13; + + + /** + * Macro for both {@link CRTCInformation} fields + * that can specify the size of the monitor's viewport + * as specified in the monitor's Extended Display + * Information Data + */ + public static final int MACRO_EDID_VIEWPORT = WIDTH_MM_EDID | HEIGHT_MM_EDID; + + /** + * Macro for all {@link CRTCInformation} fields + * that can be filled if the adjustment method have + * support for reading the monitors' Extended Display + * Information Data + */ + public static final int MACRO_EDID = EDID | MACRO_EDID_VIEWPORT | GAMMA; + + /** + * Macro for both {@link CRTCInformation} fields + * that can specify the size of the monitor's viewport + * as provided by the adjustment method without this + * library having to parse the monitor's Extended Display + * Information Data + */ + public static final int MACRO_VIEWPORT = WIDTH_MM | HEIGHT_MM; + + /** + * Macro for the {@link CRTCInformation} fields + * that specifies the CRTC's gamma ramp sizes and gamma + * ramp depth + */ + public static final int MACRO_RAMP = GAMMA_SIZE | GAMMA_DEPTH; + + /** + * Macro for the {@link CRTCInformation} fields + * that specifies the CRTC's connector type and the + * partition unique name of the connector + */ + public static final int MACRO_CONNECTOR = CONNECTOR_NAME | CONNECTOR_TYPE; + + /** + * Macro for the {@link CRTCInformation} fields + * that required there is a monitor attached to + * the connector, and that status itself + */ + public static final int MACRO_ACTIVE = MACRO_EDID | MACRO_VIEWPORT | SUBPIXEL_ORDER | ACTIVE; + + + /** + * Constructor + * + * @param edid The value for {@link edid} + * @param connector_name The value for {@link connector_name} + * @param gamma The values for {@link gamma_red}, + * {@link gamma_green} and {@link gamma_blue} + * @param ints Values for the rest of the variables + */ + public CRTCInformation(byte[] edid, String connector_name, float[] gamma, int[] ints) + { + this.edid = edid; + this.connector_name = connector_name; + this.gamma_red = gamma[0]; + this.gamma_green = gamma[1]; + this.gamma_blue = gamma[2]; + + this.edid_error = make_error(ints[0]); + this.width_mm = ints[1]; + this.width_mm_error = make_error(ints[2]); + this.height_mm = ints[3]; + this.height_mm_error = make_error(ints[4]); + this.width_mm_edid = ints[5]; + this.width_mm_edid_error = make_error(ints[6]); + this.height_mm_edid = ints[7]; + this.height_mm_edid_error = make_error(ints[8]); + this.red_gamma_size = ints[9]; + this.green_gamma_size = ints[10]; + this.blue_gamma_size = ints[11]; + this.gamma_size_error = make_error(ints[12]); + this.gamma_depth = (short)(ints[13]); + this.gamma_depth_error = make_error(ints[14]); + this.gamma_support = ints[15] != 0; + this.gamma_support_error = make_error(ints[16]); + this.subpixel_order = SubpixelOrder.VALUES[ints[17]]; + this.subpixel_order_error = make_error(ints[18]); + this.active = ints[19] != 0; + this.active_error = make_error(ints[20]); + this.connector_name_error = make_error(ints[21]); + this.connector_type = ConnectorType.VALUES[ints[22]]; + this.connector_type_error = make_error(ints[23]); + this.gamma_error = make_error(ints[24]); + + this.has_error = (this.edid_error != null) + || (this.width_mm_error != null) + || (this.height_mm_error != null) + || (this.width_mm_edid_error != null) + || (this.height_mm_edid_error != null) + || (this.gamma_size_error != null) + || (this.gamma_depth_error != null) + || (this.gamma_support_error != null) + || (this.subpixel_order_error != null) + || (this.connector_name_error != null) + || (this.connector_type_error != null); + } + + + /** + * Create an {@link LibgammaException} from an error code + * + * @param error_code The error code + * @return An {@link LibgammaException} for the error, + * {@code null} if error_code is zero + */ + private static LibgammaException make_error(int error_code) + { + return error_code == 0 ? null : new LibgammaException(error_code); + } + + + /** + * The Extended Display Identification Data associated with + * the attached monitor. This is raw byte array that is usually + * 128 bytes long. + */ + public final byte[] edid; + + /** + * Error that occurred when fetching the value for + * {@link #edid}, {@code null} on success + */ + public final LibgammaException edid_error; + + + /** + * The phyical width, in millimetres, of the viewport of the + * attached monitor, as reported by the adjustment method. This + * value may be incorrect, which is a known issue with the X + * server where it is the result of the X server attempting + * the estimate the size on its own. + * Zero means that its is not applicable, which is the case + * for projectors. + */ + public final int width_mm; + + /** + * Error that occurred when fetching the value for + * {@link #width_mm}, {@code null} on success + */ + public final LibgammaException width_mm_error; + + + /** + * The phyical height, in millimetres, of the viewport of the + * attached monitor, as reported by the adjustment method. This + * value may be incorrect, which is a known issue with the X + * server where it is the result of the X server attempting + * the estimate the size on its own. + * Zero means that its is not applicable, which is the case + * for projectors. + */ + public final int height_mm; + + /** + * Error that occurred when fetching the value for + * {@link #height_mm}, {@code null} on success + */ + public final LibgammaException height_mm_error; + + + /** + * The phyical width, in millimetres, of the viewport of the + * attached monitor, as reported by it the monitor's Extended + * Display Information Data. This value can only contain whole + * centimetres, which means that the result is always zero + * modulus ten. However, this could change with revisions of + * the EDID structure. + * Zero means that its is not applicable, which is the case + * for projectors. + */ + public final int width_mm_edid; + + /** + * Error that occurred when fetching the value for + * {@link #width_mm_edid}, {@code null} on success + */ + public final LibgammaException width_mm_edid_error; + + + /** + * The phyical height, in millimetres, of the viewport of the + * attached monitor, as reported by it the monitor's Extended + * Display Information Data. This value can only contain whole + * centimetres, which means that the result is always zero + * modulus ten. However, this could change with revisions of + * the EDID structure. + * Zero means that its is not applicable, which is the case + * for projectors. + */ + public final int height_mm_edid; + + /** + * Error that occurred when fetching the value for + * {@link #height_mm_edid}, {@code null} on success + */ + public final LibgammaException height_mm_edid_error; + + + /** + * The size of the encoding axis of the red gamma ramp + */ + public final int red_gamma_size; + + /** + * The size of the encoding axis of the green gamma ramp + */ + public final int green_gamma_size; + + /** + * The size of the encoding axis of the blue gamma ramp + */ + public final int blue_gamma_size; + + /** + * Error that occurred when fetching the values for + * {@link #red_gamma_size}, {@link #green_gamma_size} + * and {@link #blue_gamma_size}, {@code null} on success + */ + public final LibgammaException gamma_size_error; + + + /** + * The bit-depth of the value axes of gamma ramps, + * -1 for single precision floating point, and -2 for + * double precision floating point + */ + public final short gamma_depth; + + /** + * Error that occurred when fetching the value for + * {@link #gamma_depth}, {@code null} on success + */ + public final LibgammaException gamma_depth_error; + + + /** + * Whether gamma ramp adjustments are supported + */ + public final boolean gamma_support; + + /** + * Error that occurred when fetching the value for + * {@link #gamma_support}, {@code null} on success + */ + public final LibgammaException gamma_support_error; + + + /** + * The layout of the subpixels + *

+ * You cannot count on this value — especially for CRT:s — + * but it is provided anyway as a means of distinguishing monitors + */ + public final SubpixelOrder subpixel_order; + + /** + * Error that occurred when fetching the value for + * {@link #subpixel_order}, {@code null} on success + */ + public final LibgammaException subpixel_order_error; + + + /** + * Whether there is a monitors connected to the CRTC + */ + public final boolean active; + + /** + * Error that occurred when fetching the value for + * {@link #active}, {@code null} on success + */ + public final LibgammaException active_error; + + + /** + * The name of the connector as designated by the display + * server or as give by this library in case the display + * server lacks this feature + */ + public final String connector_name; + + /** + * Error that occurred when fetching the value for + * {@link #connector_name}, {@code null} on success + */ + public final LibgammaException connector_name_error; + + + /** + * The type of the connector that is associated with the CRTC + */ + public final ConnectorType connector_type; + + /** + * Error that occurred when fetching the value for + * {@link #connector_type}, {@code null} on success + */ + public final LibgammaException connector_type_error; + + + /** + * The gamma characteristics of the monitor as reported + * in its Extended Display Information Data. The value + * holds the value for the red channel. If you do not have + * and more accurate measurement of the gamma for the + * monitor this could be used to give a rought gamma + * correction; simply divide the value with 2.2 and use + * the result for the red channel in the gamma correction. + */ + public final float gamma_red; + + /** + * The gamma characteristics of the monitor as reported + * in its Extended Display Information Data. The value + * holds the value for the green channel. If you do not have + * and more accurate measurement of the gamma for the + * monitor this could be used to give a rought gamma + * correction; simply divide the value with 2.2 and use + * the result for the green channel in the gamma correction. + */ + public final float gamma_green; + + /** + * The gamma characteristics of the monitor as reported + * in its Extended Display Information Data. The value + * holds the value for the blue channel. If you do not have + * and more accurate measurement of the gamma for the + * monitor this could be used to give a rought gamma + * correction; simply divide the value with 2.2 and use + * the result for the blue channel in the gamma correction. + */ + public final float gamma_blue; + + /** + * Error that occurred when fetching the values for + * {@link #red_gamma}, {@link #green_gamma} and + * {@link #blue_gamma}, {@code null} on success + */ + public final LibgammaException gamma_error; + + + /** + * Whether any of the error fields are non-{@code null} + */ + public final boolean has_error; + + + /** + * Helper function for {@link #toString} + * + * @param error An error, may be {@code null} + * @return A textual representation of error + */ + private static String errorToString(LibgammaException error) + { + return error == null ? "" : error.toString(); + } + + + /** + * {@inheritDoc} + */ + public String toString() + { + String depth_str = Integer.toString(this.gamma_depth); + if (this.gamma_depth == -1) depth_str = "float"; + if (this.gamma_depth == -2) depth_str = "double"; + + return "" : this.connector_name) + ", " + + "connector_name_error = " + errorToString(this.connector_name_error) + ", " + + "connector_type = " + this.connector_type.toString() + ", " + + "connector_type_error = " + errorToString(this.connector_type_error) + ", " + + "gamma_red = " + Float.toString(this.gamma_red) + ", " + + "gamma_green = " + Float.toString(this.gamma_green) + ", " + + "gamma_blue = " + Float.toString(this.gamma_blue) + ", " + + "gamma_error = " + errorToString(this.gamma_error) + ", " + + "has_error = " + Boolean.toString(this.has_error) + ">"; + } + + + /** + * Convert a raw representation of an EDID to a lowercase hexadecimal representation + * + * @param edid The EDID in raw representation + * @return The EDID in lowercase hexadecimal representation + */ + public static String behex(byte[] edid) + { + char[] rc = new char[edid.length * 2]; + for (int i = 0; i < edid.length; i++) { + rc[i * 2 + 0] = "0123456789abcdef".charAt((edid[i] >> 4) & 15); + rc[i * 2 + 1] = "0123456789abcdef".charAt((edid[i] >> 0) & 15); + } + return new String(rc); + } + + /** + * Convert an hexadecimal representation of an EDID to a raw representation + * + * @param edid The EDID in hexadecimal representation + * @return The EDID in raw representation, it will be half the length + * of edid (the input value) + */ + public static byte[] unhex(String edid) + { + byte[] rc = new byte[edid.length() / 2]; + edid = edid.toLowerCase(); + for (int i = 0; i < rc.length; i++) { + rc[i] = (byte)("0123456789abcdef".indexOf(edid.charAt(i * 2 + 0)) << 4); + rc[i] |= (byte)("0123456789abcdef".indexOf(edid.charAt(i * 2 + 1)) << 0); + } + return rc; + } +} diff --git a/libgamma/ConnectorType.java b/libgamma/ConnectorType.java new file mode 100644 index 0000000..3f3aed1 --- /dev/null +++ b/libgamma/ConnectorType.java @@ -0,0 +1,148 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Types for connectors + */ +public enum ConnectorType +{ + /** + * The adjustment method does not know the connector's type + *

+ * (This could be considered an error) + */ + Unknown(0), + + /** + * Video Graphics Array (VGA) + */ + VGA(1), + + /** + * Digital Visual Interface, unknown type + */ + DVI(2), + + /** + * Digital Visual Interface, integrated (DVI-I) + */ + DVII(3), + + /** + * Digital Visual Interface, digital only (DVI-D) + */ + DVID(4), + + /** + * Digital Visual Interface, analogue only (DVI-A) + */ + DVIA(5), + + /** + * Composite video + */ + Composite(6), + + /** + * Separate Video (S-video) + */ + SVIDEO(7), + + /** + * Low-voltage differential signaling (LVDS) + */ + LVDS(8), + + /** + * Component video, usually separate cables for each channel + */ + Component(9), + + /** + * 9 pin DIN (Deutsches Institut für Normung) connector + */ + NinePinDIN(10), + + /** + * DisplayPort + */ + DisplayPort(11), + + /** + * High-Definition Multimedia Interface (HDMI), unknown type + */ + HDMI(12), + + /** + * High-Definition Multimedia Interface, type A (HDMI-A) + */ + HDMIA(13), + + /** + * High-Definition Multimedia Interface, type B (HDMI-B) + */ + HDMIB(14), + + /** + * Television, unknown connector + */ + TV(15), + + /** + * Embedded DisplayPort (eDP) + */ + eDP(16), + + /** + * A virtual connector + */ + VIRTUAL(17), + + /** + * Display Serial Interface (DSI) + */ + DSI(18), + + /** + * LFP connector + *

+ * (If you know what this is add it to Wikipedia) + */ + LFP(19); + + + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + + /** + * Subpixel orders by their numerical values + */ + public static ConnectorType[] VALUES = + { + Unknown, VGA, DVI, DVII, DVID, DVIA, Composite, SVIDEO, LVDS, Component, + NinePinDIN, DisplayPort, HDMI, HDMIA, HDMIB, TV, eDP, VIRTUAL, DSI, LFP + }; + + /** + * Constructor + * + * @param value The numerical value of the connector type + */ + private ConnectorType(int value) + { + this.value = value; + } + + /** + * The numerical value of the connector type + */ + public int value; +} diff --git a/libgamma/GammaRamps.java b/libgamma/GammaRamps.java new file mode 100644 index 0000000..8ea5d57 --- /dev/null +++ b/libgamma/GammaRamps.java @@ -0,0 +1,312 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Gamma ramp structure + * + * @param The ramp class, should be select in accordance + * with the depth parameter of the constructor: + *

+ * 8: Ramp8
+ * 16: Ramp16
+ * 32: Ramp32
+ * 64: Ramp64
+ * -1: Rampf
+ * -2: Rampd
+ */ +public class GammaRamps +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @param depth The bit-depth of the value axes of gamma ramps, + * -1 for single precision floating point, and -2 for + * double precision floating point + */ + public GammaRamps(int red_size, int green_size, int blue_size, int depth) throws LibgammaException + { + this(red_size, green_size, blue_size, (short)depth); + } + + /** + * Constructor + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @param depth The bit-depth of the value axes of gamma ramps, + * -1 for single precision floating point, and -2 for + * double precision floating point + */ + @SuppressWarnings("unchecked") + public GammaRamps(int red_size, int green_size, int blue_size, short depth) throws LibgammaException + { + long[] r; + if (depth == 8) r = libgamma_gamma_ramps8_create (red_size, green_size, blue_size); + else if (depth == 16) r = libgamma_gamma_ramps16_create(red_size, green_size, blue_size); + else if (depth == 32) r = libgamma_gamma_ramps32_create(red_size, green_size, blue_size); + else if (depth == 64) r = libgamma_gamma_ramps64_create(red_size, green_size, blue_size); + else if (depth == -1) r = libgamma_gamma_rampsf_create (red_size, green_size, blue_size); + else if (depth == -2) r = libgamma_gamma_rampsd_create (red_size, green_size, blue_size); + else + throw new IllegalArgumentException("depth must be either of: 8, 16, 32, 64, -1, -2."); + + if (r[4] != 0) + throw new LibgammaException((int)(r[4])); + + this.address = r[0]; + this.depth = depth; + + Ramp red = null; + Ramp green = null; + Ramp blue = null; + + if (depth == 8) red = (Ramp)(new Ramp8 (r[1], red_size)); + else if (depth == 16) red = (Ramp)(new Ramp16(r[1], red_size)); + else if (depth == 32) red = (Ramp)(new Ramp32(r[1], red_size)); + else if (depth == 64) red = (Ramp)(new Ramp64(r[1], red_size)); + else if (depth == -1) red = (Ramp)(new Rampf (r[1], red_size)); + else if (depth == -2) red = (Ramp)(new Rampd (r[1], red_size)); + + if (depth == 8) green = (Ramp)(new Ramp8 (r[2], green_size)); + else if (depth == 16) green = (Ramp)(new Ramp16(r[2], green_size)); + else if (depth == 32) green = (Ramp)(new Ramp32(r[2], green_size)); + else if (depth == 64) green = (Ramp)(new Ramp64(r[2], green_size)); + else if (depth == -1) green = (Ramp)(new Rampf (r[2], green_size)); + else if (depth == -2) green = (Ramp)(new Rampd (r[2], green_size)); + + if (depth == 8) blue = (Ramp)(new Ramp8 (r[3], blue_size)); + else if (depth == 16) blue = (Ramp)(new Ramp16(r[3], blue_size)); + else if (depth == 32) blue = (Ramp)(new Ramp32(r[3], blue_size)); + else if (depth == 64) blue = (Ramp)(new Ramp64(r[3], blue_size)); + else if (depth == -1) blue = (Ramp)(new Rampf (r[3], blue_size)); + else if (depth == -2) blue = (Ramp)(new Rampd (r[3], blue_size)); + + this.red = (T)red; + this.green = (T)green; + this.blue = (T)blue; + } + + + /** + * The gamma ramp for the red channel + */ + public final T red; + + /** + * The gamma ramp for the green channel + */ + public final T green; + + /** + * The gamma ramp for the blue channel + */ + public final T blue; + + /** + * The bit-depth of the value axes of gamma ramps, + * -1 for single precision floating point, and -2 for + * double precision floating point + */ + public final short depth; + + /** + * The address of the native object + */ + final long address; + + + /** + * Release resources + */ + public void close() + { + if (this.depth == 8) libgamma_gamma_ramps8_free(this.address); + else if (this.depth == 16) libgamma_gamma_ramps16_free(this.address); + else if (this.depth == 32) libgamma_gamma_ramps32_free(this.address); + else if (this.depth == 64) libgamma_gamma_ramps64_free(this.address); + else if (this.depth == -1) libgamma_gamma_rampsf_free(this.address); + else if (this.depth == -2) libgamma_gamma_rampsd_free(this.address); + } + + + /** + * {@inheritDoc} + */ + public String toString() + { + String depth_str = Integer.toString(this.depth); + if (this.depth == -1) depth_str = "float"; + if (this.depth == -1) depth_str = "double"; + + return ""; + } + + + /** + * Create and initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @return Element 0: The address of the native object
+ * Element 1: The address of the red gamma ramp
+ * Element 2: The address of the green gamma ramp
+ * Element 3: The address of the blue gamma ramp
+ * Element 4: Zero on success, an error code on error + */ + private static native long[] libgamma_gamma_ramps8_create(int red_size, int green_size, int blue_size); + + /** + * Create and initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @return Element 0: The address of the native object
+ * Element 1: The address of the red gamma ramp
+ * Element 2: The address of the green gamma ramp
+ * Element 3: The address of the blue gamma ramp
+ * Element 4: Zero on success, an error code on error + */ + private static native long[] libgamma_gamma_ramps16_create(int red_size, int green_size, int blue_size); + + /** + * Create and initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @return Element 0: The address of the native object
+ * Element 1: The address of the red gamma ramp
+ * Element 2: The address of the green gamma ramp
+ * Element 3: The address of the blue gamma ramp
+ * Element 4: Zero on success, an error code on error + */ + private static native long[] libgamma_gamma_ramps32_create(int red_size, int green_size, int blue_size); + + /** + * Create and initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @return Element 0: The address of the native object
+ * Element 1: The address of the red gamma ramp
+ * Element 2: The address of the green gamma ramp
+ * Element 3: The address of the blue gamma ramp
+ * Element 4: Zero on success, an error code on error + */ + private static native long[] libgamma_gamma_ramps64_create(int red_size, int green_size, int blue_size); + + /** + * Create and initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @return Element 0: The address of the native object
+ * Element 1: The address of the red gamma ramp
+ * Element 2: The address of the green gamma ramp
+ * Element 3: The address of the blue gamma ramp
+ * Element 4: Zero on success, an error code on error + */ + private static native long[] libgamma_gamma_rampsf_create(int red_size, int green_size, int blue_size); + + /** + * Create and initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param red_size The size of the encoding axis of the red gamma ramp + * @param green_size The size of the encoding axis of the green gamma ramp + * @param blue_size The size of the encoding axis of the blue gamma ramp + * @return Element 0: The address of the native object
+ * Element 1: The address of the red gamma ramp
+ * Element 2: The address of the green gamma ramp
+ * Element 3: The address of the blue gamma ramp
+ * Element 4: Zero on success, an error code on error + */ + private static native long[] libgamma_gamma_rampsd_create(int red_size, int green_size, int blue_size); + + + /** + * Release resources that are held by a gamma ramp strcuture that + * has been allocated by {@link #libgamma_gamma_ramps8_create} or + * otherwise initialised in the proper manner, as well as release + * the pointer to the structure + * + * @param address The gamma ramps + */ + private static native void libgamma_gamma_ramps8_free(long address); + + /** + * Release resources that are held by a gamma ramp strcuture that + * has been allocated by {@link #libgamma_gamma_ramps16_create} or + * otherwise initialised in the proper manner, as well as release + * the pointer to the structure + * + * @param address The gamma ramps + */ + private static native void libgamma_gamma_ramps16_free(long address); + + /** + * Release resources that are held by a gamma ramp strcuture that + * has been allocated by {@link #libgamma_gamma_ramps32_create} or + * otherwise initialised in the proper manner, as well as release + * the pointer to the structure + * + * @param address The gamma ramps + */ + private static native void libgamma_gamma_ramps32_free(long address); + + /** + * Release resources that are held by a gamma ramp strcuture that + * has been allocated by {@link #libgamma_gamma_ramps64_create} or + * otherwise initialised in the proper manner, as well as release + * the pointer to the structure + * + * @param address The gamma ramps + */ + private static native void libgamma_gamma_ramps64_free(long address); + + /** + * Release resources that are held by a gamma ramp strcuture that + * has been allocated by {@link #libgamma_gamma_rampsf_create} or + * otherwise initialised in the proper manner, as well as release + * the pointer to the structure + * + * @param address The gamma ramps + */ + private static native void libgamma_gamma_rampsf_free(long address); + + /** + * Release resources that are held by a gamma ramp strcuture that + * has been allocated by {@link #libgamma_gamma_rampsd_create} or + * otherwise initialised in the proper manner, as well as release + * the pointer to the structure + * + * @param address The gamma ramps + */ + private static native void libgamma_gamma_rampsd_free(long address); +} diff --git a/libgamma/Libgamma.java b/libgamma/Libgamma.java new file mode 100644 index 0000000..98e086c --- /dev/null +++ b/libgamma/Libgamma.java @@ -0,0 +1,30 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Library initialisation class + */ +class Libgamma +{ + /** + * Initialise the library + */ + static void initialise() + { + if (Libgamma.initialised) + return; + Libgamma.initialised = true; + + try { + System.loadLibrary("gamma-java"); + } catch (Throwable err) { + throw new Error(err); + } + } + + /** + * Whether {@link #initialise} has been invoked + */ + private static boolean initialised = false; +} diff --git a/libgamma/LibgammaException.java b/libgamma/LibgammaException.java new file mode 100644 index 0000000..63d8b09 --- /dev/null +++ b/libgamma/LibgammaException.java @@ -0,0 +1,411 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Class of libgamma exceptions including + * native system exceptions + *

+ * The class contains constants with libgamma error + * codes. It does however not contain system error codes. + */ +@SuppressWarnings("serial") +public class LibgammaException extends Exception +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * This error code is never used. It is only provided + * so you know its error code if you plan to iterate + * over all libgamma error codes. + */ + public static final int LIBGAMMA_ERRNO_SET = -1; + + /** + * The selected adjustment method does not exist + * or has been excluded at compile-time + */ + public static final int LIBGAMMA_NO_SUCH_ADJUSTMENT_METHOD = -2; + + /** + * The selected site does not exist + */ + public static final int LIBGAMMA_NO_SUCH_SITE = -3; + + /** + * The selected partition does not exist + */ + public static final int LIBGAMMA_NO_SUCH_PARTITION = -4; + + /** + * The selected CRTC does not exist + */ + public static final int LIBGAMMA_NO_SUCH_CRTC = -5; + + /** + * Counter overflowed when counting the number + * of available items + */ + public static final int LIBGAMMA_IMPOSSIBLE_AMOUNT = -6; + + /** + * The selected connector is disabled, it does + * not have a CRTC + */ + public static final int LIBGAMMA_CONNECTOR_DISABLED = -7; + + /** + * The selected CRTC could not be opened, + * reason unknown + */ + public static final int LIBGAMMA_OPEN_CRTC_FAILED = -8; + + /** + * The CRTC information field is not supported + * by the adjustment method + */ + public static final int LIBGAMMA_CRTC_INFO_NOT_SUPPORTED = -9; + + /** + * Failed to read the current gamma ramps for + * the selected CRTC, reason unknown + */ + public static final int LIBGAMMA_GAMMA_RAMP_READ_FAILED = -10; + + /** + * Failed to write the current gamma ramps for + * the selected CRTC, reason unknown + */ + public static final int LIBGAMMA_GAMMA_RAMP_WRITE_FAILED = -11; + + /** + * The specified ramp sizes does not match the + * ramps sizes returned by the adjustment methods + * in response to the query/command + */ + public static final int LIBGAMMA_GAMMA_RAMP_SIZE_CHANGED = -12; + + /** + * The specified ramp sizes are not identical + * which is required by the adjustment method + *

+ * (Only returned in debug mode) + */ + public static final int LIBGAMMA_MIXED_GAMMA_RAMP_SIZE = -13; + + /** + * The specified ramp sizes are not supported + * by the adjustment method + *

+ * (Only returned in debug mode) + */ + public static final int LIBGAMMA_WRONG_GAMMA_RAMP_SIZE = -14; + + /** + * The adjustment method reported that the gamma + * ramps size is 1, or perhaps even zero or negative + */ + public static final int LIBGAMMA_SINGLETON_GAMMA_RAMP = -15; + + /** + * The adjustment method failed to list + * available CRTC:s, reason unknown + */ + public static final int LIBGAMMA_LIST_CRTCS_FAILED = -16; + + /** + * Failed to acquire mode resources from the + * adjustment method + */ + public static final int LIBGAMMA_ACQUIRING_MODE_RESOURCES_FAILED = -17; + + /** + * The adjustment method reported that a negative + * number of partitions exists in the site + */ + public static final int LIBGAMMA_NEGATIVE_PARTITION_COUNT = -18; + + /** + * The adjustment method reported that a negative + * number of CRTC:s exists in the partition + */ + public static final int LIBGAMMA_NEGATIVE_CRTC_COUNT = -19; + + /** + * Device cannot be access becauses of + * insufficient permissions + */ + public static final int LIBGAMMA_DEVICE_RESTRICTED = -20; + + /** + * Device cannot be access, reason unknown + */ + public static final int LIBGAMMA_DEVICE_ACCESS_FAILED = -21; + + /** + * Device cannot be access, membership of the + * {@link #group_gid} (named by {@link #group_name} + * (can be {@code null}, if so errno may have + * been set to tell why)) is required + */ + public static final int LIBGAMMA_DEVICE_REQUIRE_GROUP = -22; + + /** + * The graphics card appear to have been removed + */ + public static final int LIBGAMMA_GRAPHICS_CARD_REMOVED = -23; + + /** + * The state of the requested information is unknown + */ + public static final int LIBGAMMA_STATE_UNKNOWN = -24; + + /** + * Failed to determine which connector the + * CRTC belongs to + */ + public static final int LIBGAMMA_CONNECTOR_UNKNOWN = -25; + + /** + * The detected connector type is not listed + * in this library and has to be updated + */ + public static final int LIBGAMMA_CONNECTOR_TYPE_NOT_RECOGNISED = -26; + + /** + * The detected subpixel order is not listed + * in this library and has to be updated + */ + public static final int LIBGAMMA_SUBPIXEL_ORDER_NOT_RECOGNISED = -27; + + /** + * The length of the EDID does not match that + * of any supported EDID structure revision + */ + public static final int LIBGAMMA_EDID_LENGTH_UNSUPPORTED = -28; + + /** + * The magic number in the EDID does not match + * that of any supported EDID structure revision + */ + public static final int LIBGAMMA_EDID_WRONG_MAGIC_NUMBER = -29; + + /** + * The EDID structure revision used by the + * mointor is not supported + */ + public static final int LIBGAMMA_EDID_REVISION_UNSUPPORTED = -30; + + /** + * The gamma characteristics field in the EDID + * is left unspecified + *

+ * (This could be considered a non-error) + */ + public static final int LIBGAMMA_GAMMA_NOT_SPECIFIED = -31; + + /** + * The checksum in the EDID is incorrect, all + * request information has been provided + * by you cannot count on it + */ + public static final int LIBGAMMA_EDID_CHECKSUM_ERROR = -32; + + /** + * Both of the errors {@link #LIBGAMMA_GAMMA_NOT_SPECIFIED} + * and {@link #LIBGAMMA_EDID_CHECKSUM_ERROR} have occurred + */ + public static final int LIBGAMMA_GAMMA_NOT_SPECIFIED_AND_EDID_CHECKSUM_ERROR = -33; + + /** + * Failed to query the gamma ramps size from the + * adjustment method, reason unknown + */ + public static final int LIBGAMMA_GAMMA_RAMPS_SIZE_QUERY_FAILED = -34; + + /** + * The selected partition could not be opened, + * reason unknown + */ + public static final int LIBGAMMA_OPEN_PARTITION_FAILED = -35; + + /** + * The selected site could not be opened, + * reason unknown + */ + public static final int LIBGAMMA_OPEN_SITE_FAILED = -36; + + /** + * Failed to query the adjustment method for + * its protocol version, reason unknown + */ + public static final int LIBGAMMA_PROTOCOL_VERSION_QUERY_FAILED = -37; + + /** + * The adjustment method's version of its + * protocol is not supported + */ + public static final int LIBGAMMA_PROTOCOL_VERSION_NOT_SUPPORTED = -38; + + /** + * The adjustment method failed to list + * available partitions, reason unknown + */ + public static final int LIBGAMMA_LIST_PARTITIONS_FAILED = -39; + + /** + * Partition exists by index, but the partition + * at that index does not exist + */ + public static final int LIBGAMMA_NULL_PARTITION = -40; + + /** + * There is not mointor connected to the + * connector of the selected CRTC + */ + public static final int LIBGAMMA_NOT_CONNECTED = -41; + + /** + * Data extraction from a reply from the + * adjustment method failed, reason unknown + */ + public static final int LIBGAMMA_REPLY_VALUE_EXTRACTION_FAILED = -42; + + /** + * No EDID property was found on the output + */ + public static final int LIBGAMMA_EDID_NOT_FOUND = -43; + + /** + * Failed to list properties on the output, + * reason unknown + */ + public static final int LIBGAMMA_LIST_PROPERTIES_FAILED = -44; + + /** + * Failed to query a property's value from + * the output, reason unknown + */ + public static final int LIBGAMMA_PROPERTY_VALUE_QUERY_FAILED = -45; + + /** + * A request for information on an output + * failed, reason unknown + */ + public static final int LIBGAMMA_OUTPUT_INFORMATION_QUERY_FAILED = -46; + + + /** + * The number of the libgamma error with the + * lowest number. If this is lower than the + * number your program thinks it should be sould + * update your program for new errors. + */ + public static final int LIBGAMMA_ERROR_MIN = -46; + + + /** + * Constructor + * + * @param error_code The error code + */ + public LibgammaException(int error_code) + { + this.error_code = error_code; + if (error_code == LIBGAMMA_DEVICE_REQUIRE_GROUP) { + this.group_gid = libgamma_group_gid(); + this.group_name = libgamma_group_name(); + } else { + this.group_gid = 0; + this.group_name = null; + } + this.string = error_code < 0 ? name_of_error(error_code) : strerror(error_code); + } + + + /** + * The error code + *

+ * Cannot be {@link #LIBGAMMA_ERRNO_SET} + */ + public final int error_code; + + /** + * Group that the user needs to be a member of if + * {@link #error_code} is {@link #LIBGAMMA_DEVICE_REQUIRE_GROUP} + */ + public final int group_gid; + + /** + * Group that the user needs to be a member of if + * {@link #error_code} is {@link #LIBGAMMA_DEVICE_REQUIRE_GROUP}, + * {@code null} if the name of the group {@link #group_gid} + * cannot be determined + */ + public final String group_name; + + /** + * Name of textual description of the error + */ + public final String string; + + + /** + * {@inheritDoc} + */ + @Override + public String toString() + { + return this.string; + } + + + /** + * Returns the name of the definition associated with + * a libgamma error code + * + * @param value The error code + * @return The name of the definition associated with the error code, + * {@code null} if the error code does not exist + */ + public static native String name_of_error(int value); + + /** + * Return the value of a libgamma error definition + * refered to by name + * + * @param name The name of the definition associated with the error code + * @return The error code, zero if the name is {@code null} + * or does not refer to a libgamma error + */ + public static native int value_of_error(String name); + + /** + * Acquire the value that should go to {@link #group_gid} + * + * @return The value that should go to {@link #group_gid} + */ + private static native int libgamma_group_gid(); + + /** + * Acquire the value that should go to {@link #group_name} + * + * @return The value that should go to {@link #group_name} + */ + private static native String libgamma_group_name(); + + /** + * Get a textual description of a system error code + * + * @param error_code The error code + * @return A textual description of the error code + */ + private static native String strerror(int error_code); +} diff --git a/libgamma/Partition.java b/libgamma/Partition.java new file mode 100644 index 0000000..cb480d3 --- /dev/null +++ b/libgamma/Partition.java @@ -0,0 +1,125 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Partition state + *

+ * Probably the majority of display server only one partition + * per site. However, X.org can, and traditional used to have + * on multi-headed environments, multiple partitions per site. + * In X.org partitions are called 'screens'. It is not to be + * confused with monitor. A screen is a collection of monitors, + * and the mapping from monitors to screens is a surjection. + * On hardware-level adjustment methods, such as Direct + * Rendering Manager, a partition is a graphics card. + */ +public class Partition +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param site The site this partition belongs to + * @param partition The index of the partition + */ + public Partition(Site site, int partition) throws LibgammaException + { + this.site = site; + this.partition = partition; + long[] r = libgamma_partition_create(site.address, partition); + this.address = r[0]; + this.crtcs_available = (int)(r[1]); + if (r[2] != 0) + throw new LibgammaException((int)(r[2])); + } + + + /** + * The site this partition belongs to + */ + public final Site site; + + /** + * The index of the partition + */ + public final int partition; + + /** + * The number of CRTC:s that are available under this + * partition. Note that the CRTC:s are not necessarily + * online. + */ + public final int crtcs_available; + + /** + * The address of the native object + */ + final long address; + + + /** + * Release resources + */ + public void close() + { + libgamma_partition_free(this.address); + } + + /** + * Restore the gamma ramps all CRTC:s within the partition to the system settings + */ + public void restore() throws LibgammaException + { + int r = libgamma_partition_restore(this.address); + if (r != 0) + throw new LibgammaException(r); + } + + + /** + * {@inheritDoc} + */ + public String toString() + { + return ""; + } + + + /** + * Create a partition state + * + * @param site The site state for the site that the partition belongs to + * @param partition The index of the partition within the site + * @return Element 0: The value for {@link #address}
+ * Element 1: The value for {@link #crtcs_available}
+ * Element 2: Error code, zero on success + */ + private static native long[] libgamma_partition_create(long site, int partition); + + /** + * Release all resources held by a partition state + * and free the partition state pointer + * + * @param address The partition state + */ + private static native void libgamma_partition_free(long address); + + /** + * Restore the gamma ramps all CRTC:s within a partition to the system settings + * + * @param address The partition state + * @return Zero on success, and error code on failure + */ + private static native int libgamma_partition_restore(long address); +} diff --git a/libgamma/Ramp.java b/libgamma/Ramp.java new file mode 100644 index 0000000..6f66683 --- /dev/null +++ b/libgamma/Ramp.java @@ -0,0 +1,160 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single gamma ramp + */ +public abstract class Ramp +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Ramp(long address, int size) + { + this.size = size; + this.address = address; + } + + + /** + * The size of the encoding axis of the gamma ramp + */ + public final int size; + + /** + * The address of the native object + */ + protected final long address; + + + /** + * {@inheritDoc} + */ + public String toString() + { + return ""; + } + + + /** + * Read the value of a stop in an 8-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @return The value of the stop + */ + protected static native short libgamma_gamma_ramps8_get(long address, int stop); + + /** + * Read the value of a stop in a 16-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @return The value of the stop + */ + protected static native int libgamma_gamma_ramps16_get(long address, int stop); + + /** + * Read the value of a stop in a 32-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @return The value of the stop + */ + protected static native long libgamma_gamma_ramps32_get(long address, int stop); + + /** + * Read the value of a stop in a 64-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @return The value of the stop + */ + protected static native long libgamma_gamma_ramps64_get(long address, int stop); + + /** + * Read the value of a stop in a single precision floating point ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @return The value of the stop + */ + protected static native float libgamma_gamma_rampsf_get(long address, int stop); + + /** + * Read the value of a stop in a double precision floating point ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @return The value of the stop + */ + protected static native double libgamma_gamma_rampsd_get(long address, int stop); + + + /** + * Set the value of a stop in an 8-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @param value The value of the stop + */ + protected static native void libgamma_gamma_ramps8_set(long address, int stop, short value); + + /** + * Set the value of a stop in a 16-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @param value The value of the stop + */ + protected static native void libgamma_gamma_ramps16_set(long address, int stop, int value); + + /** + * Set the value of a stop in a 32-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @param value The value of the stop + */ + protected static native void libgamma_gamma_ramps32_set(long address, int stop, long value); + + /** + * Set the value of a stop in a 64-bit ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @param value The value of the stop + */ + protected static native void libgamma_gamma_ramps64_set(long address, int stop, long value); + + /** + * Set the value of a stop in a single precision floating point ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @param value The value of the stop + */ + protected static native void libgamma_gamma_rampsf_set(long address, int stop, float value); + + /** + * Set the value of a stop in a double precision floating point ramp + * + * @param address The address of the ramp + * @param stop The index of the stop + * @param value The value of the stop + */ + protected static native void libgamma_gamma_rampsd_set(long address, int stop, double value); +} diff --git a/libgamma/Ramp16.java b/libgamma/Ramp16.java new file mode 100644 index 0000000..a78bf2e --- /dev/null +++ b/libgamma/Ramp16.java @@ -0,0 +1,79 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single 16-bit gamma ramp + */ +public class Ramp16 extends Ramp +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Ramp16(long address, int size) + { + super(address, size); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @return The value of the stop + */ + public int get(int stop) + { + return libgamma_gamma_ramps16_get(this.address, stop); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public long set(int stop, long value) + { + libgamma_gamma_ramps16_set(this.address, stop, (int)value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public int set(int stop, int value) + { + libgamma_gamma_ramps16_set(this.address, stop, value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public short set(int stop, short value) + { + libgamma_gamma_ramps16_set(this.address, stop, value); + return value; + } +} diff --git a/libgamma/Ramp32.java b/libgamma/Ramp32.java new file mode 100644 index 0000000..27e3ebc --- /dev/null +++ b/libgamma/Ramp32.java @@ -0,0 +1,57 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single 32-bit gamma ramp + */ +public class Ramp32 extends Ramp +{ + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Ramp32(long address, int size) + { + super(address, size); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @return The value of the stop + */ + public long get(int stop) + { + return libgamma_gamma_ramps32_get(this.address, stop); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public long set(int stop, long value) + { + libgamma_gamma_ramps32_set(this.address, stop, value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public int set(int stop, int value) + { + libgamma_gamma_ramps32_set(this.address, stop, value); + return value; + } +} diff --git a/libgamma/Ramp64.java b/libgamma/Ramp64.java new file mode 100644 index 0000000..8a5db0a --- /dev/null +++ b/libgamma/Ramp64.java @@ -0,0 +1,44 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single 64-bit gamma ramp + */ +public class Ramp64 extends Ramp +{ + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Ramp64(long address, int size) + { + super(address, size); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @return The value of the stop + */ + public long get(int stop) + { + return libgamma_gamma_ramps64_get(this.address, stop); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public long set(int stop, long value) + { + libgamma_gamma_ramps64_set(this.address, stop, value); + return value; + } +} diff --git a/libgamma/Ramp8.java b/libgamma/Ramp8.java new file mode 100644 index 0000000..ff7d36e --- /dev/null +++ b/libgamma/Ramp8.java @@ -0,0 +1,83 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single 8-bit gamma ramp + */ +public class Ramp8 extends Ramp +{ + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Ramp8(long address, int size) + { + super(address, size); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @return The value of the stop + */ + public short get(short stop) + { + return libgamma_gamma_ramps8_get(this.address, stop); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public long set(int stop, long value) + { + libgamma_gamma_ramps8_set(this.address, stop, (short)value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public int set(int stop, int value) + { + libgamma_gamma_ramps8_set(this.address, stop, (short)value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public short set(int stop, short value) + { + libgamma_gamma_ramps8_set(this.address, stop, value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public byte set(int stop, byte value) + { + libgamma_gamma_ramps8_set(this.address, stop, value); + return value; + } +} diff --git a/libgamma/Rampd.java b/libgamma/Rampd.java new file mode 100644 index 0000000..e1a3ad8 --- /dev/null +++ b/libgamma/Rampd.java @@ -0,0 +1,66 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single double percision floating point gamma ramp + */ +public class Rampd extends Ramp +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Rampd(long address, int size) + { + super(address, size); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @return The value of the stop + */ + public double get(int stop) + { + return libgamma_gamma_rampsd_get(this.address, stop); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public float set(int stop, float value) + { + libgamma_gamma_rampsd_set(this.address, stop, value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public double set(int stop, double value) + { + libgamma_gamma_rampsd_set(this.address, stop, value); + return value; + } +} diff --git a/libgamma/Rampf.java b/libgamma/Rampf.java new file mode 100644 index 0000000..fcfa7b5 --- /dev/null +++ b/libgamma/Rampf.java @@ -0,0 +1,57 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * A single single percision floating point gamma ramp + */ +public class Rampf extends Ramp +{ + /** + * Constructor + * + * @param address The address of the native object + * @param size The size of the encoding axis of the gamma ramp + */ + Rampf(long address, int size) + { + super(address, size); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @return The value of the stop + */ + public float get(int stop) + { + return libgamma_gamma_rampsf_get(this.address, stop); + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public float set(int stop, float value) + { + libgamma_gamma_rampsf_set(this.address, stop, value); + return value; + } + + /** + * Read the value of a stop + * + * @param stop The index of the stop + * @param value The new value of the stop + * @return The new value of the stop + */ + public double set(int stop, double value) + { + libgamma_gamma_rampsf_set(this.address, stop, (float)value); + return value; + } +} diff --git a/libgamma/Site.java b/libgamma/Site.java new file mode 100644 index 0000000..6ce2ad4 --- /dev/null +++ b/libgamma/Site.java @@ -0,0 +1,133 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Site state + *

+ * On operating systems that integrate a graphical environment + * there is usually just one site. However, one systems with + * pluggable graphics, like Unix-like systems such as GNU/Linux + * and the BSD:s, there can usually be any (feasible) number of + * sites. In X.org parlance they are called displays. + */ +public class Site +{ + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Constructor + * + * @param method The adjustmet method + * @param site The site identifier + */ + public Site(AdjustmentMethod method, String site) throws LibgammaException + { + this.method = method; + this.site = site; + long[] r = libgamma_site_create(method.value, site); + this.address = r[0]; + this.partitions_available = (int)(r[1]); + if (r[2] != 0) + throw new LibgammaException((int)(r[2])); + } + + + /** + * This field specifies, for the methods if this library, + * which adjustment method (display server and protocol) + * is used to adjust the gamma ramps + */ + public final AdjustmentMethod method; + + /** + * The site identifier. It can either be {@code null} or + * a string. {@code null} indicates the default site. On + * systems like the Unix-like systems, where the graphics + * are pluggable, this is usually resolved by an environment + * variable, such as "DISPLAY" for X.org. + */ + public final String site; + + /** + * The number of partitions that is available on this site. + * Probably the majority of display server only one partition + * per site. However, X.org can, and traditional used to have + * on multi-headed environments, multiple partitions per site. + * In X.org partitions are called 'screens'. It is not to be + * confused with monitor. A screen is a collection of monitors, + * and the mapping from monitors to screens is a surjection. + * On hardware-level adjustment methods, such as Direct + * Rendering Manager, a partition is a graphics card. + */ + public final int partitions_available; + + /** + * The address of the native object + */ + final long address; + + + /** + * Release resources + */ + public void close() + { + libgamma_site_free(this.address); + } + + /** + * Restore the gamma ramps all CRTC:s within the site to the system settings + */ + public void restore() throws LibgammaException + { + int r = libgamma_site_restore(this.address); + if (r != 0) + throw new LibgammaException(r); + } + + + /** + * {@inheritDoc} + */ + public String toString() + { + return ""; + } + + /** + * Create a site state + * + * @param method The adjustment method (display server and protocol) + * @param site The site identifier + * @return Element 0: The value for {@link #address}
+ * Element 1: The value for {@link #partitions_available}
+ * Element 2: Error code, zero on success + */ + private static native long[] libgamma_site_create(int method, String site); + + /** + * Release all resources held by a site state + * and free the site state pointer + * + * @param address The site state + */ + private static native void libgamma_site_free(long address); + + /** + * Restore the gamma ramps all CRTC:s within a site to the system settings + * + * @param address The site state + * @return Zero on success, and error code on failure + */ + private static native int libgamma_site_restore(long address); +} diff --git a/libgamma/SubpixelOrder.java b/libgamma/SubpixelOrder.java new file mode 100644 index 0000000..4db2ff9 --- /dev/null +++ b/libgamma/SubpixelOrder.java @@ -0,0 +1,77 @@ +/* See LICENSE file for copyright and license details. */ +package libgamma; + + +/** + * Orders for subpixels. Currently the possible values are + * very biased to LCD, Plasma and monochrome monitors + */ +public enum SubpixelOrder +{ + /** + * The adjustment method does not know the order of the subpixels + *

+ * (This could be considered an error) + */ + UNKNOWN(0), + + /** + * There are no subpixels in the monitor + */ + NONE(1), + + /** + * The subpixels are ordered red, green and then blue, from left to right + */ + HORIZONTAL_RGB(2), + + /** + * The subpixels are ordered blue, green and then red, from left to right + */ + HORIZONTAL_BGR(3), + + /** + * The subpixels are ordered red, green and then blue, from the top down + */ + VERTICAL_RGB(4), + + /** + * The subpixels are ordered blue, green and then red, from the top down + */ + VERTICAL_BGR(5); + + + /** + * Type initialiser + */ + static + { + Libgamma.initialise(); + } + + + /** + * Subpixel orders by their numerical values + */ + public static SubpixelOrder[] VALUES = + { + UNKNOWN, NONE, HORIZONTAL_RGB, HORIZONTAL_BGR, VERTICAL_RGB, VERTICAL_BGR + }; + + + /** + * Constructor + * + * @param value The numerical value of the subpixel order + */ + private SubpixelOrder(int value) + { + this.value = value; + } + + + /** + * The numerical value of the subpixel order + */ + public int value; +} -- cgit v1.2.3-70-g09d2