diff options
| -rw-r--r-- | src/libgamma.py | 1 | ||||
| -rw-r--r-- | src/libgamma_error.py | 3 | ||||
| -rw-r--r-- | src/libgamma_facade.py | 146 | ||||
| -rw-r--r-- | src/libgamma_method.py | 35 | ||||
| -rw-r--r-- | src/libgamma_native_error.pyx | 7 | ||||
| -rw-r--r-- | src/libgamma_native_error.w32.pyx | 4 | ||||
| -rw-r--r-- | src/libgamma_native_facade.pyx | 1312 | ||||
| -rw-r--r-- | src/libgamma_native_method.pyx | 12 |
8 files changed, 1504 insertions, 16 deletions
diff --git a/src/libgamma.py b/src/libgamma.py index 1dbf49e..34c646c 100644 --- a/src/libgamma.py +++ b/src/libgamma.py @@ -19,4 +19,5 @@ along with this library. If not, see <http://www.gnu.org/licenses/>. from libgamma_error import * from libgamma_method import * +from libgamma_facade import * diff --git a/src/libgamma_error.py b/src/libgamma_error.py index b9530fa..7b16886 100644 --- a/src/libgamma_error.py +++ b/src/libgamma_error.py @@ -115,8 +115,7 @@ def name_of_error(value : int) -> str: @param value The error code. @return The name of the definition associated with the error code, - `None` if the error code does not exist. The return string - should not be `free`:d. + `None` if the error code does not exist. ''' from libgamma_native_error import libgamma_native_name_of_error return libgamma_native_name_of_error(value) diff --git a/src/libgamma_facade.py b/src/libgamma_facade.py new file mode 100644 index 0000000..830a0b9 --- /dev/null +++ b/src/libgamma_facade.py @@ -0,0 +1,146 @@ +# -*- python -*- +''' +pylibgamma — Python 3 wrapper for libgamma +Copyright © 2014 Mattias Andrée (maandree@member.fsf.org) + +This library is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this library. If not, see <http://www.gnu.org/licenses/>. +''' + + +from libgamma_method import MethodCapabilities + + + +def list_methods(operation : int) -> list + ''' + 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<int> A list of available adjustment methods. + ''' + from libgamma_native_method import libgamma_native_list_methods + return libgamma_native_list_methods(method) + + +def is_method_available(method : int) -> bool: + ''' + 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. + ''' + from libgamma_native_method import libgamma_native_is_method_available + return not libgamma_native_is_method_available(method) == 0 + + +def method_capabilities(method : int) -> MethodCapabilities: + ''' + Return the capabilities of an adjustment method. + + @param this The data structure to fill with the method's capabilities + @param method The adjustment method (display server and protocol). + ''' + from libgamma_native_method import libgamma_native_method_capabilities + caps = libgamma_native_method_capabilities(method) + MethodCapabilities(*caps) + + +def method_default_site(method : int) -> str: + ''' + Return the capabilities of an adjustment method. + + @param method The adjustment method (display server and protocol.) + @return The default site, `None` if it cannot be determined or + if multiple sites are not supported by the adjustment + method. + ''' + from libgamma_native_method import libgamma_native_method_default_site + return libgamma_native_method_default_site(method) + + +def method_default_site_variable(method : int) -> str: + ''' + Return the capabilities of an adjustment method. + + @param method The adjustment method (display server and protocol.) + @return The environ variables that is used to determine the + default site. `None` if there is none, that is, if + the method does not support multiple sites. + ''' + from libgamma_native_method import libgamma_native_method_default_site_variable + return libgamma_native_method_default_site_variable(method) + + + +def behex_edid(edid : bytes) -> str: + ''' + 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. + ''' + return behex_edid_lowercase(edid) + + +def behex_edid_lowercase(edid : bytes) -> str: + ''' + 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. + ''' + rc = '' + for b in edid: + rc += '0123456789abcdef'[(b >> 4) & 15] + rc += '0123456789abcdef'[(b >> 0) & 15] + return rc + + +def behex_edid_uppercase(edid : bytes) -> str: + ''' + Convert a raw representation of an EDID to an uppercase hexadecimal representation. + + @param edid The EDID in raw representation. + @return The EDID in uppercase hexadecimal representation. + ''' + rc = '' + for b in edid: + rc += '0123456789ABCDEF'[(b >> 4) & 15] + rc += '0123456789ABCDEF'[(b >> 0) & 15] + return rc + + +def unhex_edid(edid : str) -> bytes: + ''' + Convert an hexadecimal representation of an EDID to a raw representation. + + @param edid The EDID in hexadecimal representation. + @return The EDID in raw representation. + ''' + rc = [] + edid = edid.lowercase() + for i in range(0, len(edid), 2): + a, b = edid[i + 0], edid[i + 1] + a = '0123456789abcdef'.find(a) << 4 + b = '0123456789abcdef'.find(b) << 0 + rc.append(a | b) + return bytes(rc) + diff --git a/src/libgamma_method.py b/src/libgamma_method.py index b702151..67993f4 100644 --- a/src/libgamma_method.py +++ b/src/libgamma_method.py @@ -271,11 +271,42 @@ class CRTCInformation: of an error identifier provided by this library. ''' - def __init__(self): + def __init__(self, data): ''' Constructor + + @param data:list The value of each variable ''' - pass + self.edid = data[0] + self.edid_error = data[1] + self.width_mm = data[2] + self.width_mm_error = data[3] + self.height_mm = data[4] + self.height_mm_error = data[5] + self.width_mm_edid = data[6] + self.width_mm_edid_error = data[7] + self.height_mm_edid = data[8] + self.height_mm_edid_error = data[9] + self.red_gamma_size = data[10] + self.green_gamma_size = data[11] + self.blue_gamma_size = data[12] + self.gamma_size_error = data[13] + self.gamma_depth = data[14] + self.gamma_depth_error = data[15] + self.gamma_support = data[16] + self.gamma_support_error = data[17] + self.subpixel_order = data[18] + self.subpixel_order_error = data[19] + self.active = data[20] + self.active_error = data[21] + self.connector_name = data[22] + self.connector_name_error = data[23] + self.connector_type = data[24] + self.connector_type_error = data[25] + self.gamma_red = data[26] + self.gamma_green = data[27] + self.gamma_blue = data[28] + self.gamma_error = data[29] LIBGAMMA_CONNECTOR_TYPE_Unknown = 0 diff --git a/src/libgamma_native_error.pyx b/src/libgamma_native_error.pyx index 8696d10..b10dc5a 100644 --- a/src/libgamma_native_error.pyx +++ b/src/libgamma_native_error.pyx @@ -106,7 +106,7 @@ def libgamma_native_get_group_name() -> str: cannot be determined. ''' cdef bytes bs - if libgamma_group_name == NULL: + if libgamma_group_name is NULL: return None bs = libgamma_group_name return bs.decode('utf-8', 'strict') @@ -157,13 +157,12 @@ def libgamma_native_name_of_error(value : int) -> str: @param value The error code. @return The name of the definition associated with the error code, - `None` if the error code does not exist. The return string - should not be `free`:d. + `None` if the error code does not exist. ''' cdef const char* name cdef bytes bs name = libgamma_name_of_error(<int>value) - if name == NULL: + if name is NULL: return None bs = name return bs.decode('utf-8', 'strict') diff --git a/src/libgamma_native_error.w32.pyx b/src/libgamma_native_error.w32.pyx index 4d5aaac..673da5d 100644 --- a/src/libgamma_native_error.w32.pyx +++ b/src/libgamma_native_error.w32.pyx @@ -104,7 +104,7 @@ def libgamma_native_get_group_name() -> str: cannot be determined. ''' cdef bytes bs - if libgamma_group_name == NULL: + if libgamma_group_name is NULL: return None bs = libgamma_group_name return bs.decode('utf-8', 'strict') @@ -161,7 +161,7 @@ def libgamma_native_name_of_error(value : int) -> str: cdef const char* name cdef bytes bs name = libgamma_name_of_error(<int>value) - if name == NULL: + if name is NULL: return None bs = name return bs.decode('utf-8', 'strict') diff --git a/src/libgamma_native_facade.pyx b/src/libgamma_native_facade.pyx new file mode 100644 index 0000000..de15bd6 --- /dev/null +++ b/src/libgamma_native_facade.pyx @@ -0,0 +1,1312 @@ +# -*- python -*- +''' +pylibgamma — Python 3 wrapper for libgamma +Copyright © 2014 Mattias Andrée (maandree@member.fsf.org) + +This library is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this library. If not, see <http://www.gnu.org/licenses/>. +''' + +cimport cython + +from libc.stddef cimport size_t +from libc.stdlib cimport malloc, free +from libc.stdint cimport int32_t, uint8_t, uint16_t, uint32_t, uint64_t + + +ctypedef int libgamma_subpixel_order_t +ctypedef int libgamma_connector_type_t + + +cdef extern from "libgamma/libgamma-method.h": + + ctypedef struct libgamma_method_capabilities_t: + # Capabilities of adjustment methods. + + int32_t crtc_information + # OR of the CRTC information fields in `libgamma_crtc_information_t` + # that may (but can fail) be read successfully. + + unsigned default_site_known # : 1 + # Whether the default site is known, if true the site is integrated + # to the system or can be determined using environment variables. + + unsigned multiple_sites # : 1 + # Whether the adjustment method supports multiple sites rather + # than just the default site. + + unsigned multiple_partitions # : 1 + # Whether the adjustment method supports multiple partitions + # per site. + + unsigned multiple_crtcs # : 1 + # Whether the adjustment method supports multiple CRTC:s + # per partition per site. + + unsigned partitions_are_graphics_cards # : 1 + # Whether the partition to graphics card is a bijection. + + unsigned site_restore # : 1 + # Whether the adjustment method supports `libgamma_site_restore`. + + unsigned partition_restore # : 1 + # Whether the adjustment method supports `libgamma_partition_restore`. + + unsigned crtc_restore # : 1 + # Whether the adjustment method supports `libgamma_crtc_restore`. + + unsigned identical_gamma_sizes # : 1 + # Whether the `red_gamma_size`, `green_gamma_size` and `blue_gamma_size` + # fields in `libgamma_crtc_information_t` will always have the same + # values as each other for the adjustment method. + + unsigned fixed_gamma_size # : 1 + # Whether the `red_gamma_size`, `green_gamma_size` and `blue_gamma_size` + # fields in `libgamma_crtc_information_t` will always be filled with the + # same value for the adjustment method. + + unsigned fixed_gamma_depth # : 1 + # Whether the `gamma_depth` field in `libgamma_crtc_information_t` + # will always be filled with the same value for the adjustment method. + + unsigned real # : 1 + # Whether the adjustment method will actually perform adjustments. + + unsigned fake # : 1 + # Whether the adjustment method is implement using a translation layer. + + + ctypedef struct libgamma_site_state_t: + # 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. + + void* data + # Adjustment method implementation specific data. + # You as a user of this library should not touch this. + + int method + # This field specifies, for the methods if this library, + # which adjustment method (display server and protocol) + # is used to adjust the gamma ramps. + + char* site + # The site identifier. It can either be `NULL` or a string. + # `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. + + size_t partitions_available + # 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. + + + ctypedef struct libgamma_partition_state_t: + # 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. + + void* data + # Adjustment method implementation specific data. + # You as a user of this library should not touch this. + + libgamma_site_state_t* site + # The site this partition belongs to. + + size_t partition + # The index of the partition. + + size_t crtcs_available + # The number of CRTC:s that are available under this + # partition. Note that the CRTC:s are not necessarily + # online. + + + ctypedef struct libgamma_crtc_state_t: + # 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. + + void* data + # Adjustment method implementation specific data. + # You as a user of this library should not touch this. + + libgamma_partition_state_t* partition + # The partition this CRTC belongs to. + + size_t crtc + #* The index of the CRTC within its partition. + + + ctypedef struct libgamma_crtc_information_t: + # Cathode ray tube controller information data structure. + + unsigned char* edid + # The Extended Display Identification Data associated with + # the attached monitor. This is raw byte array that is usually + # 128 bytes long. It is not NUL-terminate, rather its length + # is stored in `edid_length`. + + size_t edid_length + # The length of `edid`. + + int edid_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + size_t width_mm + # 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. + + int width_mm_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + size_t height_mm + # 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. + + int height_mm_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + size_t width_mm_edid + # 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. + + int width_mm_edid_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + size_t height_mm_edid + # 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. + + int height_mm_edid_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + size_t red_gamma_size + # The size of the encoding axis of the red gamma ramp. + + size_t green_gamma_size + # The size of the encoding axis of the green gamma ramp. + + size_t blue_gamma_size + # The size of the encoding axis of the blue gamma ramp. + + int gamma_size_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + signed gamma_depth + # The bit-depth of the value axes of gamma ramps, + # -1 for single precision floating point, and -2 for + # double precision floating point. + + int gamma_depth_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + int gamma_support + # Non-zero gamma ramp adjustments are supported. + + int gamma_support_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + libgamma_subpixel_order_t subpixel_order + # 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. + + int subpixel_order_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + int active + # Whether there is a monitors connected to the CRTC. + + int active_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + char* connector_name + # 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. + + int connector_name_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + libgamma_connector_type_t connector_type + # The type of the connector that is associated with the CRTC. + + int connector_type_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + float gamma_red + # 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. + + float gamma_green + # 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. + + float gamma_blue + # 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. + + int gamma_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + + ctypedef struct libgamma_gamma_ramps8_t: + # Gamma ramp structure for 8-bit gamma ramps. + size_t red_size + # The size of `red`. + size_t green_size + # The size of `green`. + size_t blue_size + # The size of `blue`. + uint8_t* red + # The gamma ramp for the red channel. + uint8_t* green + # The gamma ramp for the green channel. + uint8_t* blue + # The gamma ramp for the blue channel. + + ctypedef struct libgamma_gamma_ramps16_t: + # Gamma ramp structure for 16-bit gamma ramps. + size_t red_size + # The size of `red`. + size_t green_size + # The size of `green`. + size_t blue_size + # The size of `blue`. + uint16_t* red + # The gamma ramp for the red channel. + uint16_t* green + # The gamma ramp for the green channel. + uint16_t* blue + # The gamma ramp for the blue channel. + + ctypedef struct libgamma_gamma_ramps32_t: + # Gamma ramp structure for 32-bit gamma ramps. + size_t red_size + # The size of `red`. + size_t green_size + # The size of `green`. + size_t blue_size + # The size of `blue`. + uint32_t* red + # The gamma ramp for the red channel. + uint32_t* green + # The gamma ramp for the green channel. + uint32_t* blue + # The gamma ramp for the blue channel. + + ctypedef struct libgamma_gamma_ramps64_t: + # Gamma ramp structure for 64-bit gamma ramps. + size_t red_size + # The size of `red`. + size_t green_size + # The size of `green`. + size_t blue_size + # The size of `blue`. + uint64_t* red + # The gamma ramp for the red channel. + uint64_t* green + # The gamma ramp for the green channel. + uint64_t* blue + # The gamma ramp for the blue channel. + + ctypedef struct libgamma_gamma_rampsf_t: + # Gamma ramp structure for `float` gamma ramps. + size_t red_size + # The size of `red`. + size_t green_size + # The size of `green`. + size_t blue_size + # The size of `blue`. + float* red + # The gamma ramp for the red channel. + float* green + # The gamma ramp for the green channel. + float* blue + # The gamma ramp for the blue channel. + + ctypedef struct libgamma_gamma_rampsd_t: + # Gamma ramp structure for `double` gamma ramps. + size_t red_size + # The size of `red`. + size_t green_size + # The size of `green`. + size_t blue_size + # The size of `blue`. + double* red + # The gamma ramp for the red channel. + double* green + # The gamma ramp for the green channel. + double* blue + # The gamma ramp for the blue channel. + + +cdef extern size_t libgamma_list_methods(int* methods, size_t buf_size, int operation) +''' +List available adjustment methods by their order of preference based on the environment. + +@param methods Output array of methods, should be able to hold `LIBGAMMA_METHOD_COUNT` elements. +@param buf_size The number of elements that fits in `methods`, it should be `LIBGAMMA_METHOD_COUNT`, + This is used to avoid writing outside the output buffer if this library adds new + adjustment methods without the users of the library recompiling. +@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 The number of element that have been stored in `methods`, or should + have been stored if the buffer was large enough. +''' + + +cdef extern int libgamma_is_method_available(int method) +''' +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. +''' + + +cdef extern void libgamma_method_capabilities(libgamma_method_capabilities_t* this, int method) +''' +Return the capabilities of an adjustment method. + +@param this The data structure to fill with the method's capabilities +@param method The adjustment method (display server and protocol). +''' + + +cdef extern char* libgamma_method_default_site(int method) +''' +Return the capabilities of an adjustment method. + +@param method The adjustment method (display server and protocol.) +@return The default site, `NULL` if it cannot be determined or + if multiple sites are not supported by the adjustment + method. This value should not be `free`:d. +''' + + +cdef extern const char* libgamma_method_default_site_variable(int method) +''' +Return the capabilities of an adjustment method. + +@param method The adjustment method (display server and protocol.) +@return The environ variables that is used to determine the + default site. `NULL` if there is none, that is, if + the method does not support multiple sites. + This value should not be `free`:d. +''' + + + +cdef extern int libgamma_site_initialise(libgamma_site_state_t* this, int method, char* site) +''' +Initialise an allocated site state. + +@param this The site state to initialise. +@param method The adjustment method (display server and protocol.) +@param site The site identifier, unless it is `NULL` it must a + `free`:able. One the state is destroyed the library + will attempt to free it. There you should not free + it yourself, and it must not be a string constant + or allocate on the stack. Note however that it will + not be `free`:d if this function fails. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern void libgamma_site_free(libgamma_site_state_t* this) +''' +Release all resources held by a site state +and free the site state pointer. + +@param this The site state. +''' + + +cdef extern int libgamma_site_restore(libgamma_site_state_t* this) +''' +Restore the gamma ramps all CRTC:s with a site to the system settings. + +@param this The site state. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_partition_initialise(libgamma_partition_state_t* this, libgamma_site_state_t* site, size_t partition) +''' +Initialise an allocated partition state. + +@param this The partition state to initialise. +@param site The site state for the site that the partition belongs to. +@param partition The index of the partition within the site. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern void libgamma_partition_free(libgamma_partition_state_t* this) +''' +Release all resources held by a partition state +and free the partition state pointer. + +@param this The partition state. +''' + + +cdef extern int libgamma_partition_restore(libgamma_partition_state_t* this) +''' +Restore the gamma ramps all CRTC:s with a partition to the system settings. + +@param this The partition state. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_crtc_initialise(libgamma_crtc_state_t* this, libgamma_partition_state_t* partition, size_t crtc) +''' +Initialise an allocated CRTC state. + +@param this The CRTC state to initialise. +@param partition The partition state for the partition that the CRTC belongs to. +@param crtc The index of the CRTC within the partition. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern void libgamma_crtc_free(libgamma_crtc_state_t* this) +''' +Release all resources held by a CRTC state +and free the CRTC state pointer. + +@param this The CRTC state. +''' + + +cdef extern int libgamma_crtc_restore(libgamma_crtc_state_t* this) +''' +Restore the gamma ramps for a CRTC to the system settings for that CRTC. + +@param this The CRTC state +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_get_crtc_information(libgamma_crtc_information_t* this, libgamma_crtc_state_t* crtc, int32_t fields) +''' +Read information about a CRTC. + +@param this Instance of a data structure to fill with the information about the 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 Zero on success, -1 on error. On error refer to the error reports in `this`. +''' + + +cdef extern void libgamma_crtc_information_destroy(libgamma_crtc_information_t* this) +''' +Release all resources in an information data structure for a CRTC. + +@param this The CRTC information. +''' + + + +cdef extern int libgamma_crtc_get_gamma_ramps8(libgamma_crtc_state_t* this, libgamma_gamma_ramps8_t* ramps) +''' +Get current the gamma ramps for a CRTC, 8-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps8(libgamma_crtc_state_t* this, libgamma_gamma_ramps8_t ramps) +''' +Set the gamma ramps for a CRTC, 8-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to apply. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_crtc_get_gamma_ramps16(libgamma_crtc_state_t* this, libgamma_gamma_ramps16_t* ramps) +''' +Get current the gamma ramps for a CRTC, 16-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps16(libgamma_crtc_state_t* this, libgamma_gamma_ramps16_t ramps) +''' +Set the gamma ramps for a CRTC, 16-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to apply. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_crtc_get_gamma_ramps32(libgamma_crtc_state_t* this, libgamma_gamma_ramps32_t* ramps) +''' +Get current the gamma ramps for a CRTC, 32-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to fill with the current values. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps32(libgamma_crtc_state_t* this, libgamma_gamma_ramps32_t ramps) +''' +Set the gamma ramps for a CRTC, 32-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to apply. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_crtc_get_gamma_ramps64(libgamma_crtc_state_t* this, libgamma_gamma_ramps64_t* ramps) +''' +Get current the gamma ramps for a CRTC, 64-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to fill with the current values. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps64(libgamma_crtc_state_t* this, libgamma_gamma_ramps64_t ramps) +''' +Set the gamma ramps for a CRTC, 64-bit gamma-depth version. + +@param this The CRTC state. +@param ramps The gamma ramps to apply. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_crtc_set_gamma_rampsf(libgamma_crtc_state_t* this, libgamma_gamma_rampsf_t ramps) +''' +Set the gamma ramps for a CRTC, `float` version. + +@param this The CRTC state. +@param ramps The gamma ramps to apply. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern int libgamma_crtc_get_gamma_rampsf(libgamma_crtc_state_t* this, libgamma_gamma_rampsf_t* ramps) +''' +Get current the gamma ramps for a CRTC, `float` version. + +@param this The CRTC state. +@param ramps The gamma ramps to fill with the current values. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +cdef extern int libgamma_crtc_get_gamma_rampsd(libgamma_crtc_state_t* this, libgamma_gamma_rampsd_t* ramps) +''' +Get current the gamma ramps for a CRTC, `double` version. + +@param this The CRTC state. +@param ramps The gamma ramps to fill with the current values. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +cdef extern int libgamma_crtc_set_gamma_rampsd(libgamma_crtc_state_t* this, libgamma_gamma_rampsd_t ramps) +''' +Set the gamma ramps for a CRTC, `double` version. + +@param this The CRTC state. +@param ramps The gamma ramps to apply. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + + +def libgamma_native_list_methods(operation : int) -> list: + ''' + 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<int> A list of available adjustment methods. + ''' + cdef int* methods + cdef size_t buf_size + cdef size_t r + buf_size = 6 + methods = <int*>malloc(buf_size * sizeof(size_t)) + if methods == NULL: + raise MemoryError() + r = libgamma_list_methods(methods, buf_size, operation) + if r > buf_size: + buf_size = r + free(methods) + methods = <int*>malloc(buf_size * sizeof(size_t)) + if methods == NULL: + raise MemoryError() + libgamma_list_methods(methods, buf_size, operation) + rc = [] + for i in range(r): + rc.append(methods[i]) + free(methods) + return rc + + +def libgamma_native_is_method_available(method : int) -> int: + ''' + 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. + ''' + return int(libgamma_is_method_available(<int>method)) + + +def libgamma_native_method_capabilities(method : int) -> tuple: + ''' + Return the capabilities of an adjustment method. + + @param method The adjustment method (display server and protocol). + @return :(int, int) Input parameters for `MethodCapabilities.__init__` + ''' + cdef libgamma_method_capabilities_t caps + libgamma_method_capabilities(&caps, <int>method) + booleans = 0 + crtc_information = int(caps.crtc_information) + booleans |= (0 if caps.default_site_known == 0 else 1) << 0 + booleans |= (0 if caps.multiple_sites == 0 else 1) << 1 + booleans |= (0 if caps.multiple_partitions == 0 else 1) << 2 + booleans |= (0 if caps.multiple_crtcs == 0 else 1) << 3 + booleans |= (0 if caps.partitions_are_graphics_cards == 0 else 1) << 4 + booleans |= (0 if caps.site_restore == 0 else 1) << 5 + booleans |= (0 if caps.partition_restore == 0 else 1) << 6 + booleans |= (0 if caps.crtc_restore == 0 else 1) << 7 + booleans |= (0 if caps.identical_gamma_sizes == 0 else 1) << 8 + booleans |= (0 if caps.fixed_gamma_size == 0 else 1) << 9 + booleans |= (0 if caps.fixed_gamma_depth == 0 else 1) << 10 + booleans |= (0 if caps.real == 0 else 1) << 11 + booleans |= (0 if caps.fake == 0 else 1) << 12 + return (crtc_information, booleans) + + +def libgamma_native_method_default_site(method : int) -> str: + ''' + Return the capabilities of an adjustment method. + + @param method The adjustment method (display server and protocol.) + @return The default site, `None` if it cannot be determined or + if multiple sites are not supported by the adjustment + method. + ''' + cdef char* var + cdef bytes bs + var = libgamma_method_default_site(<int>method) + bs = var + return bs.decode('utf-8', 'strict') + + +def libgamma_native_method_default_site_variable(method : int) -> str: + ''' + Return the capabilities of an adjustment method. + + @param method The adjustment method (display server and protocol.) + @return The environ variables that is used to determine the + default site. `None` if there is none, that is, if + the method does not support multiple sites. + ''' + cdef const char* var + cdef bytes bs + var = libgamma_method_default_site_variable(<int>method) + bs = var + return bs.decode('utf-8', 'strict') + + + +#def int libgamma_native_site_initialise(libgamma_site_state_t* this, int method, char* site) +''' +Initialise an allocated site state. + +@param this The site state to initialise. +@param method The adjustment method (display server and protocol.) +@param site The site identifier, unless it is `NULL` it must a + `free`:able. One the state is destroyed the library + will attempt to free it. There you should not free + it yourself, and it must not be a string constant + or allocate on the stack. Note however that it will + not be `free`:d if this function fails. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +def void libgamma_native_site_destroy(this : int): + ''' + Release all resources held by a site state. + + @param this The site state. + ''' + cdef size_t this_address + cdef libgamma_site_state_t* this_ + this_address = <size_t>this + this_ = <libgamma_site_state_t*><void*>this_address + libgamma_site_free(this_) + + +def int libgamma_native_site_restore(this : int) -> int: + ''' + Restore the gamma ramps all CRTC:s with a site to the system settings. + + @param this The site state. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef libgamma_site_state_t* this_ + this_address = <size_t>this + this_ = <libgamma_site_state_t*><void*>this_address + return int(libgamma_site_restore(this_)) + + + +#def int libgamma_native_partition_initialise(libgamma_partition_state_t* this, libgamma_site_state_t* site, size_t partition) +''' +Initialise an allocated partition state. + +@param this The partition state to initialise. +@param site The site state for the site that the partition belongs to. +@param partition The index of the partition within the site. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +def libgamma_native_partition_free(this : int): + ''' + Release all resources held by a partition state + and free the partition state pointer. + + @param this The partition state. + ''' + cdef size_t this_address + cdef libgamma_partition_state_t* this_ + this_address = <size_t>this + this_ = <libgamma_partition_state_t*><void*>this_address + libgamma_partition_free(this_) + + +def libgamma_native_partition_restore(this : int) -> int: + ''' + Restore the gamma ramps all CRTC:s with a partition to the system settings. + + @param this The partition state. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef libgamma_partition_state_t* this_ + this_address = <size_t>this + this_ = <libgamma_partition_state_t*><void*>this_address + return int(libgamma_partition_restore(this_)) + + + +#def int libgamma_native_crtc_initialise(libgamma_crtc_state_t* this, libgamma_partition_state_t* partition, size_t crtc) +''' +Initialise an allocated CRTC state. + +@param this The CRTC state to initialise. +@param partition The partition state for the partition that the CRTC belongs to. +@param crtc The index of the CRTC within the partition. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. +''' + + +def libgamma_native_crtc_free(this : int): + ''' + Release all resources held by a CRTC state + and free the CRTC state pointer. + + @param this The CRTC state. + ''' + cdef size_t this_address + cdef libgamma_crtc_state_t* this_ + this_address = <size_t>this + this_ = <libgamma_crtc_state_t*><void*>this_address + libgamma_crtc_free(this_) + + +def libgamma_native_crtc_restore(this : int) -> int: + ''' + Restore the gamma ramps for a CRTC to the system settings for that CRTC. + + @param this The CRTC state + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef libgamma_crtc_state_t* this_ + this_address = <size_t>this + this_ = <libgamma_crtc_state_t*><void*>this_address + return int(libgamma_crtc_restore(this_)) + + + +def libgamma_native_get_crtc_information(crtc : int, fields : int) -> tuple: + ''' + Read information about a CRTC. + + @param crtc The state of the CRTC whose information should be read. + @param field OR:ed identifiers for the information about the CRTC that should be read. + @return :(list, :int) First value: Input parametrs for `CRTCInformation.__init__` + Second value: Zero on success, -1 on error. On error refer to the error reports in the return. + ''' + cdef libgamma_crtc_information_t info + cdef size_t crtc_address + cdef libgamma_crtc_state_t* crtc_ + cdef bytes bs + crtc_address = <size_t>crtc + crtc_ = <libgamma_crtc_state_t*><void*>crtc_address + r = int(libgamma_get_crtc_information(&info, crtc_, <int32_t>fields)) + rc = [] + connector_name = None + if info.connector_name is not NULL: + bs = info.connector_name + connector_name = bs.decode('utf-8', 'strict') + edid = None + if info.edid is not NULL: + bs = info.edid[:info.edid_length] + edid = bs + rc.append(edid) + rc.append(int(info.edid_error)) + rc.append(int(info.width_mm)) + rc.append(int(info.width_mm_error)) + rc.append(int(info.height_mm)) + rc.append(int(info.height_mm_error)) + rc.append(int(info.width_mm_edid)) + rc.append(int(info.width_mm_edid_error)) + rc.append(int(info.height_mm_edid)) + rc.append(int(info.height_mm_edid_error)) + rc.append(int(info.red_gamma_size)) + rc.append(int(info.green_gamma_size)) + rc.append(int(info.blue_gamma_size)) + rc.append(int(info.gamma_size_error)) + rc.append(int(info.gamma_depth)) + rc.append(int(info.gamma_depth_error)) + rc.append(int(info.gamma_support)) + rc.append(int(info.gamma_support_error)) + rc.append(int(info.subpixel_order)) + rc.append(int(info.subpixel_order_error)) + rc.append(int(info.active)) + rc.append(int(info.active_error)) + rc.append(connector_name) + rc.append(int(info.connector_name_error)) + rc.append(int(info.connector_type)) + rc.append(int(info.connector_type_error)) + rc.append(float(info.gamma_red)) + rc.append(float(info.gamma_green)) + rc.append(float(info.gamma_blue)) + rc.append(int(info.gamma_error)) + libgamma_get_crtc_destroy(&info) + return (rc, r) + + + +def libgamma_native_crtc_get_gamma_ramps8(this : int, ramps : int) -> int: + ''' + Get current the gamma ramps for a CRTC, 8-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to fill with the current values. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps8_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps8_t*><void*>ramps_address + return int(libgamma_crtc_get_gamma_ramps8(this_, ramps_)) + + +def libgamma_native_crtc_set_gamma_ramps8(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 8-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to apply. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps8_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps8_t*><void*>ramps_address + return int(libgamma_crtc_set_gamma_ramps8(this_, ramps_[0])) + + + +def libgamma_native_crtc_get_gamma_ramps16(this : int, ramps : int) -> int: + ''' + Get current the gamma ramps for a CRTC, 16-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to fill with the current values. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps16_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps16_t*><void*>ramps_address + return int(libgamma_crtc_get_gamma_ramps16(this_, ramps_)) + + +def libgamma_native_crtc_set_gamma_ramps16(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 16-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to apply. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps16_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps16_t*><void*>ramps_address + return int(libgamma_crtc_set_gamma_ramps16(this_, ramps_[0])) + + + +def libgamma_native_crtc_get_gamma_ramps32(this : int, ramps : int) -> int: + ''' + Get current the gamma ramps for a CRTC, 32-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to fill with the current values. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps32_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps32_t*><void*>ramps_address + return int(libgamma_crtc_get_gamma_ramps32(this_, ramps_)) + + +def libgamma_native_crtc_set_gamma_ramps32(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 32-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to apply. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps32_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps32_t*><void*>ramps_address + return int(libgamma_crtc_set_gamma_ramps32(this_, ramps_[0])) + + + +def libgamma_native_crtc_get_gamma_ramps64(this : int, ramps : int) -> int: + ''' + Get current the gamma ramps for a CRTC, 64-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to fill with the current values. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps64_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps64_t*><void*>ramps_address + return int(libgamma_crtc_get_gamma_ramps64(this_, ramps_)) + + +def libgamma_native_crtc_set_gamma_ramps64(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 64-bit gamma-depth version. + + @param this The CRTC state. + @param ramps The gamma ramps to apply. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_ramps64_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_ramps64_t*><void*>ramps_address + return int(libgamma_crtc_set_gamma_ramps64(this_, ramps_[0])) + + + +def libgamma_native_crtc_get_gamma_rampsf(this : int, ramps : int) -> int: + ''' + Get current the gamma ramps for a CRTC, `float` version. + + @param this The CRTC state. + @param ramps The gamma ramps to fill with the current values. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_rampsf_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_rampsf_t*><void*>ramps_address + return int(libgamma_crtc_get_gamma_rampsf(this_, ramps_)) + + +def libgamma_native_crtc_set_gamma_rampsf(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, `float` version. + + @param this The CRTC state. + @param ramps The gamma ramps to apply. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_rampsf_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_rampsf_t*><void*>ramps_address + return int(libgamma_crtc_set_gamma_rampsf(this_, ramps_[0])) + + + +def libgamma_native_crtc_get_gamma_rampsd(this : int, ramps : int) -> int: + ''' + Get current the gamma ramps for a CRTC, `double` version. + + @param this The CRTC state. + @param ramps The gamma ramps to fill with the current values. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_rampsd_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_rampsd_t*><void*>ramps_address + return int(libgamma_crtc_get_gamma_rampsd(this_, ramps_)) + + +def libgamma_native_crtc_set_gamma_rampsd(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, `double` version. + + @param this The CRTC state. + @param ramps The gamma ramps to apply. + @return Zero on success, otherwise (negative) the value of an + error identifier provided by this library. + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t* this_ + cdef libgamma_gamma_rampsd_t* ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t*><void*>this_address + ramps_ = <libgamma_gamma_rampsd_t*><void*>ramps_address + return int(libgamma_crtc_set_gamma_rampsd(this_, ramps_[0])) + diff --git a/src/libgamma_native_method.pyx b/src/libgamma_native_method.pyx index 7e9a867..58ab1a3 100644 --- a/src/libgamma_native_method.pyx +++ b/src/libgamma_native_method.pyx @@ -273,7 +273,7 @@ def libgamma_native_gamma_ramps8_create(red_size : int, green_size : int, blue_s cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps8_t)) cdef libgamma_gamma_ramps8_t* item = <libgamma_gamma_ramps8_t*>allocation cdef size_t red, green, blue - if item == NULL: + if item is NULL: return errno red = <size_t><void*>(item.red) green = <size_t><void*>(item.green) @@ -339,7 +339,7 @@ def libgamma_native_gamma_ramps16_create(red_size : int, green_size : int, blue_ cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps16_t)) cdef libgamma_gamma_ramps16_t* item = <libgamma_gamma_ramps16_t*>allocation cdef size_t red, green, blue - if item == NULL: + if item is NULL: return errno red = <size_t><void*>(item.red) green = <size_t><void*>(item.green) @@ -405,7 +405,7 @@ def libgamma_native_gamma_ramps32_create(red_size : int, green_size : int, blue_ cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps32_t)) cdef libgamma_gamma_ramps32_t* item = <libgamma_gamma_ramps32_t*>allocation cdef size_t red, green, blue - if item == NULL: + if item is NULL: return errno red = <size_t><void*>(item.red) green = <size_t><void*>(item.green) @@ -471,7 +471,7 @@ def libgamma_native_gamma_ramps64_create(red_size : int, green_size : int, blue_ cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps64_t)) cdef libgamma_gamma_ramps64_t* item = <libgamma_gamma_ramps64_t*>allocation cdef size_t red, green, blue - if item == NULL: + if item is NULL: return errno red = <size_t><void*>(item.red) green = <size_t><void*>(item.green) @@ -537,7 +537,7 @@ def libgamma_native_gamma_rampsf_create(red_size : int, green_size : int, blue_s cdef void* allocation = malloc(sizeof(libgamma_gamma_rampsf_t)) cdef libgamma_gamma_rampsf_t* item = <libgamma_gamma_rampsf_t*>allocation cdef size_t red, green, blue - if item == NULL: + if item is NULL: return errno red = <size_t><void*>(item.red) green = <size_t><void*>(item.green) @@ -603,7 +603,7 @@ def libgamma_native_gamma_rampsd_create(red_size : int, green_size : int, blue_s cdef void* allocation = malloc(sizeof(libgamma_gamma_rampsd_t)) cdef libgamma_gamma_rampsd_t* item = <libgamma_gamma_rampsd_t*>allocation cdef size_t red, green, blue - if item == NULL: + if item is NULL: return errno red = <size_t><void*>(item.red) green = <size_t><void*>(item.green) |