diff options
Diffstat (limited to 'libgamma_method.py')
| -rw-r--r-- | libgamma_method.py | 1093 |
1 files changed, 1093 insertions, 0 deletions
diff --git a/libgamma_method.py b/libgamma_method.py new file mode 100644 index 0000000..c606959 --- /dev/null +++ b/libgamma_method.py @@ -0,0 +1,1093 @@ +# See LICENSE file for copyright and license details. +from libgamma_error import create_error + + +LIBGAMMA_METHOD_DUMMY = 0 +''' +The identifier for the dummy adjustment method. +This method can be configured and is useful for +testing your program's ability to handle errors. +''' + +LIBGAMMA_METHOD_X_RANDR = 1 +''' +The identifier for the adjustment method with +uses the RandR protocol under the X display server +''' + +LIBGAMMA_METHOD_X_VIDMODE = 2 +''' +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). +''' + +LIBGAMMA_METHOD_LINUX_DRM = 3 +''' +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. +''' + +LIBGAMMA_METHOD_W32_GDI = 4 +''' +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. +''' + +LIBGAMMA_METHOD_QUARTZ_CORE_GRAPHICS = 5 +''' +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. +''' + + +LIBGAMMA_METHOD_MAX = 5 +''' +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 +''' + +LIBGAMMA_METHOD_COUNT = (LIBGAMMA_METHOD_MAX + 1) +''' +The number adjustment methods provided by this library. +Note however that this includes adjstment methods that +have been removed at compile-time. +''' + + +class MethodCapabilities: + ''' + Capabilities of adjustment methods + + ---- Integer variables ---- + + @variable crtc_information OR of the CRTC information fields in `CRTCInformation` + that may (but can fail) be read successfully + + ---- Boolean variables ---- + + @variable default_site_known Whether the default site is known, if true the site is integrated + to the system or can be determined using environment variables + @variable multiple_sites Whether the adjustment method supports multiple sites rather + than just the default site + @variable multiple_partitions Whether the adjustment method supports multiple partitions + per site + @variable multiple_crtcs Whether the adjustment method supports multiple CRTC:s + per partition per site + @variable partitions_are_graphics_cards Whether the partition to graphics card is a bijection + @variable site_restore Whether the adjustment method supports `site_restore` + @variable partition_restore Whether the adjustment method supports `partition_restore` + @variable crtc_restore Whether the adjustment method supports `crtc_restore` + @variable identical_gamma_sizes Whether the `red_gamma_size`, `green_gamma_size` and + `blue_gamma_size` fields in `CRTCInformation` will always + have the same values as each other for the adjustment method + @variable fixed_gamma_size Whether the `red_gamma_size`, `green_gamma_size` and + `blue_gamma_size` fields in `CRTCInformation` will always be + filled with the same value for the adjustment method + @variable fixed_gamma_depth Whether the `gamma_depth` field in `CRTCInformation` will + always be filled with the same value for the adjustment method + @variable real Whether the adjustment method will actually perform adjustments + @variable fake Whether the adjustment method is implement using a translation + layer + ''' + + def __init__(self, crtc_information : int = 0, booleans : int = 0): + ''' + Constructor + + @param crtc_information The value for `CRTCInformation` + @param booleans The value for each boolean variable + ''' + self.crtc_information = crtc_information + self.default_site_known = (booleans & (1 << 0)) != 0 + self.multiple_sites = (booleans & (1 << 1)) != 0 + self.multiple_partitions = (booleans & (1 << 2)) != 0 + self.multiple_crtcs = (booleans & (1 << 3)) != 0 + self.partitions_are_graphics_cards = (booleans & (1 << 4)) != 0 + self.site_restore = (booleans & (1 << 5)) != 0 + self.partition_restore = (booleans & (1 << 6)) != 0 + self.crtc_restore = (booleans & (1 << 7)) != 0 + self.identical_gamma_sizes = (booleans & (1 << 8)) != 0 + self.fixed_gamma_size = (booleans & (1 << 9)) != 0 + self.fixed_gamma_depth = (booleans & (1 << 10)) != 0 + self.real = (booleans & (1 << 11)) != 0 + self.fake = (booleans & (1 << 12)) != 0 + + +class CRTCInformation: + ''' + Cathode ray tube controller information data structure + + @variable edid:bytes The Extended Display Identification Data associated with + the attached monitor. This is raw byte array that is usually + 128 bytes long. + @variable edid_error:int 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 + + @variable width_mm:int 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. + @variable width_mm_error:int 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 + @variable height_mm:int 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. + @variable height_mm_error:int 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 + + @variable width_mm_edid:int 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. + @variable width_mm_edid_error:int 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 + @variable height_mm_edid:int 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. + @variable height_mm_edid_error:int 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 + + @variable red_gamma_size:int The size of the encoding axis of the red gamma ramp + @variable green_gamma_size:int The size of the encoding axis of the green gamma ramp + @variable blue_gamma_size:int The size of the encoding axis of the blue gamma ramp + @variable gamma_size_error:int 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 + + @variable gamma_depth:int The bit-depth of the value axes of gamma ramps, + -1 for single precision floating point, and -2 for + double precision floating point + @variable gamma_depth_error:int 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 + + @variable gamma_support:int Non-zero gamma ramp adjustments are supported + @variable gamma_support_error:int 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 + + @variable subpixel_order:int 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. + @variable subpixel_order_error:int 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 + + @variable active:bool Whether there is a monitors connected to the CRTC + @variable active_error:int 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 + + @variable connector_name:str 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 + @variable connector_name_error:int 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 + + @variable connector_type:int The type of the connector that is associated with the CRTC + @variable connector_type_error:int 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 + + @variable gamma_red:float 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. + @variable gamma_green:float 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. + @variable gamma_blue:float 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. + @variable gamma_error:int 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 + ''' + + def __init__(self, data): + ''' + Constructor + + @param data:list The value of each variable + ''' + 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 +''' +The adjustment method does not know the connector's type +(This could be considered an error) +''' + +LIBGAMMA_CONNECTOR_TYPE_VGA = 1 +''' +Video Graphics Array (VGA) +''' + +LIBGAMMA_CONNECTOR_TYPE_DVI = 2 +''' +Digital Visual Interface, unknown type +''' + +LIBGAMMA_CONNECTOR_TYPE_DVII = 3 +''' +Digital Visual Interface, integrated (DVI-I) +''' + +LIBGAMMA_CONNECTOR_TYPE_DVID = 4 +''' +Digital Visual Interface, digital only (DVI-D) +''' + +LIBGAMMA_CONNECTOR_TYPE_DVIA = 5 +''' +Digital Visual Interface, analogue only (DVI-A) +''' + +LIBGAMMA_CONNECTOR_TYPE_Composite = 6 +''' +Composite video +''' + +LIBGAMMA_CONNECTOR_TYPE_SVIDEO = 7 +''' +Separate Video (S-video) +''' + +LIBGAMMA_CONNECTOR_TYPE_LVDS = 8 +''' +Low-voltage differential signaling (LVDS) +''' + +LIBGAMMA_CONNECTOR_TYPE_Component = 9 +''' +Component video, usually separate cables for each channel +''' + +LIBGAMMA_CONNECTOR_TYPE_9PinDIN = 10 +''' +9 pin DIN (Deutsches Institut für Normung) connector +''' + +LIBGAMMA_CONNECTOR_TYPE_DisplayPort = 11 +''' +DisplayPort +''' + +LIBGAMMA_CONNECTOR_TYPE_HDMI = 12 +''' +High-Definition Multimedia Interface (HDMI), unknown type +''' + +LIBGAMMA_CONNECTOR_TYPE_HDMIA = 13 +''' +High-Definition Multimedia Interface, type A (HDMI-A) +''' + +LIBGAMMA_CONNECTOR_TYPE_HDMIB = 14 +''' +High-Definition Multimedia Interface, type B (HDMI-B) +''' + +LIBGAMMA_CONNECTOR_TYPE_TV = 15 +''' +Television, unknown connector +''' + +LIBGAMMA_CONNECTOR_TYPE_eDP = 16 +''' +Embedded DisplayPort (eDP) +''' + +LIBGAMMA_CONNECTOR_TYPE_VIRTUAL = 17 +''' +A virtual connector +''' + +LIBGAMMA_CONNECTOR_TYPE_DSI = 18 +''' +Display Serial Interface (DSI) +''' + +LIBGAMMA_CONNECTOR_TYPE_LFP = 19 +''' +LFP connector +(If you know what this is add it to Wikipedia) +''' + + +LIBGAMMA_CONNECTOR_TYPE_COUNT = 20 +''' +The number of `LIBGAMMA_CONNECTOR_*` values defined +''' + + + +LIBGAMMA_SUBPIXEL_ORDER_UNKNOWN = 0 +''' +The adjustment method does not know the order of the subpixels +(This could be considered an error) +''' + +LIBGAMMA_SUBPIXEL_ORDER_NONE = 1 +''' +There are no subpixels in the monitor +''' + +LIBGAMMA_SUBPIXEL_ORDER_HORIZONTAL_RGB = 2 +''' +The subpixels are ordered red, green and then blue, from left to right +''' + +LIBGAMMA_SUBPIXEL_ORDER_HORIZONTAL_BGR = 3 +''' +The subpixels are ordered blue, green and then red, from left to right +''' + +LIBGAMMA_SUBPIXEL_ORDER_VERTICAL_RGB = 4 +''' +The subpixels are ordered red, green and then blue, from the top down +''' + +LIBGAMMA_SUBPIXEL_ORDER_VERTICAL_BGR = 5 +''' +The subpixels are ordered blue, green and then red, from the top down +''' + + +LIBGAMMA_SUBPIXEL_ORDER_COUNT = 6 +''' +The number of `LIBGAMMA_SUBPIXEL_ORDER_*` values defined +''' + + + +LIBGAMMA_CRTC_INFO_EDID = 1 << 0 +''' +For a `CRTCInformation` fill in the values for +`edid` and `edid_length` and report errors to `edid_error` +''' + +LIBGAMMA_CRTC_INFO_WIDTH_MM = 1 << 1 +''' +For a `CRTCInformation` fill in the value for +`width_mm` and report errors to `width_mm_error` +''' + +LIBGAMMA_CRTC_INFO_HEIGHT_MM = 1 << 2 +''' +For a `CRTCInformation` fill in the value for +`height_mm` and report errors to `height_mm_error` +''' + +LIBGAMMA_CRTC_INFO_WIDTH_MM_EDID = 1 << 3 +''' +For a `CRTCInformation` fill in the value for +`width_mm_edid` and report errors to `width_mm_edid_error` +''' + +LIBGAMMA_CRTC_INFO_HEIGHT_MM_EDID = 1 << 4 +''' +For a `CRTCInformation` fill in the value for +`height_mm_edid` and report errors to `height_mm_edid_error` +''' + +LIBGAMMA_CRTC_INFO_GAMMA_SIZE = 1 << 5 +''' +For a `CRTCInformation` fill in the values for +`red_gamma_size`, `green_gamma_size` and `blue_gamma_size`, +and report errors to `gamma_size_error` +''' + +LIBGAMMA_CRTC_INFO_GAMMA_DEPTH = 1 << 6 +''' +For a `CRTCInformation` fill in the value for +`gamma_depth` and report errors to `gamma_depth_error` +''' + +LIBGAMMA_CRTC_INFO_GAMMA_SUPPORT = 1 << 7 +''' +For a `CRTCInformation` fill in the value for +`gamma_support` and report errors to `gamma_support_error` +''' + +LIBGAMMA_CRTC_INFO_SUBPIXEL_ORDER = 1 << 8 +''' +For a `CRTCInformation` fill in the value for +`subpixel_order` and report errors to `subpixel_order_error` +''' + +LIBGAMMA_CRTC_INFO_ACTIVE = 1 << 9 +''' +For a `CRTCInformation` fill in the value for +`active` and report errors to `active_error` +''' + +LIBGAMMA_CRTC_INFO_CONNECTOR_NAME = 1 << 10 +''' +For a `CRTCInformation` fill in the value for +`connector_name` and report errors to `connector_name_error` +''' + +LIBGAMMA_CRTC_INFO_CONNECTOR_TYPE = 1 << 11 +''' +For a `CRTCInformation` fill in the value for +`connector_type` and report errors to `connector_type_error` +''' + +LIBGAMMA_CRTC_INFO_GAMMA = 1 << 12 +''' +For a `CRTCInformation` fill in the values for +`gamma_red`, `gamma_green` and `gamma_blue` and +report errors to `gamma_error` +''' + + +LIBGAMMA_CRTC_INFO_COUNT = 13 +''' +The number of `LIBGAMMA_CRTC_INFO_*` values defined +''' + + + +LIBGAMMA_CRTC_INFO_MACRO_EDID_VIEWPORT = LIBGAMMA_CRTC_INFO_WIDTH_MM_EDID | \ + LIBGAMMA_CRTC_INFO_HEIGHT_MM_EDID +''' +Macro for both `CRTCInformation` fields that can +specify the size of the monitor's viewport as specified +in the monitor's Extended Display Information Data +''' + +LIBGAMMA_CRTC_INFO_MACRO_EDID = LIBGAMMA_CRTC_INFO_EDID | \ + LIBGAMMA_CRTC_INFO_MACRO_EDID_VIEWPORT | \ + LIBGAMMA_CRTC_INFO_GAMMA +''' +Macro for all `CRTCInformation` fields that can be +filled if the adjustment method have support for +reading the monitors' Extended Display Information Data +''' + +LIBGAMMA_CRTC_INFO_MACRO_VIEWPORT = LIBGAMMA_CRTC_INFO_WIDTH_MM | \ + LIBGAMMA_CRTC_INFO_HEIGHT_MM +''' +Macro for both `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 +''' + +LIBGAMMA_CRTC_INFO_MACRO_RAMP = LIBGAMMA_CRTC_INFO_GAMMA_SIZE | \ + LIBGAMMA_CRTC_INFO_GAMMA_DEPTH +''' +Macro for the `CRTCInformation` fields that specifies +the CRTC's gamma ramp sizes and gamma ramp depth +''' + +LIBGAMMA_CRTC_INFO_MACRO_CONNECTOR = LIBGAMMA_CRTC_INFO_CONNECTOR_NAME | \ + LIBGAMMA_CRTC_INFO_CONNECTOR_TYPE +''' +Macro for the `CRTCInformation` fields that specifies +the CRTC's connector type and the partition unique +name of the connector +''' + +LIBGAMMA_CRTC_INFO_MACRO_ACTIVE = LIBGAMMA_CRTC_INFO_MACRO_EDID | \ + LIBGAMMA_CRTC_INFO_MACRO_VIEWPORT | \ + LIBGAMMA_CRTC_INFO_SUBPIXEL_ORDER | \ + LIBGAMMA_CRTC_INFO_ACTIVE +''' +Macro for the `CRTCInformation` fields that required +there is a monitor attached to the connector, and +that status itself +''' + + + +class GammaRamps: + ''' + Gamma ramp structure + ''' + + class Ramp: + ''' + A gamma ramp for one single channel + ''' + + def __init__(self, ramp, size : int, depth : int): + ''' + Constructor + + @param ramp The gamma ramp + @param size The number of stops in the gamma ramp + @param depth The depth of the gamma ramp + ''' + from libgamma_native_method import libgamma_native_gamma_ramps8_get + from libgamma_native_method import libgamma_native_gamma_ramps16_get + from libgamma_native_method import libgamma_native_gamma_ramps32_get + from libgamma_native_method import libgamma_native_gamma_ramps64_get + from libgamma_native_method import libgamma_native_gamma_rampsf_get + from libgamma_native_method import libgamma_native_gamma_rampsd_get + from libgamma_native_method import libgamma_native_gamma_ramps8_set + from libgamma_native_method import libgamma_native_gamma_ramps16_set + from libgamma_native_method import libgamma_native_gamma_ramps32_set + from libgamma_native_method import libgamma_native_gamma_ramps64_set + from libgamma_native_method import libgamma_native_gamma_rampsf_set + from libgamma_native_method import libgamma_native_gamma_rampsd_set + self._size = size + self._ramp = ramp + if depth == 8: fs = (libgamma_native_gamma_ramps8_get, libgamma_native_gamma_ramps8_set) + elif depth == 16: fs = (libgamma_native_gamma_ramps16_get, libgamma_native_gamma_ramps16_set) + elif depth == 32: fs = (libgamma_native_gamma_ramps32_get, libgamma_native_gamma_ramps32_set) + elif depth == 64: fs = (libgamma_native_gamma_ramps64_get, libgamma_native_gamma_ramps64_set) + elif depth == -1: fs = (libgamma_native_gamma_rampsf_get, libgamma_native_gamma_rampsf_set) + elif depth == -2: fs = (libgamma_native_gamma_rampsd_get, libgamma_native_gamma_rampsd_set) + (self._get, self._set) = fs + + + @property + def size(self) -> int: + ''' + Get the number of stops in the gamma ramp + + @return The number of stops in the gamma ramp + ''' + return self._size + + @size.setter + def size(self, value : int): + ''' + It is not possible to change this attribute, but + a setter is required for the getter to function + ''' + raise AttributeError('cannot resize ramp') + + def __len__(self) -> int: + ''' + Get the number of stops in the gamma ramp + + @return The number of stops in the gamma ramp + ''' + return self._size + + def __getitem__(self, indices): + ''' + Read the gamma ramp + + @param indices:slice The stops to read + @return :list<int|float> The values of the read stops + + -- OR -- + + @param indices:int The index of the stop to read + @return :int|float The value of the read stop + ''' + if isinstance(indices, slice): + start = indices.start + stop = indices.stop + step = indices.step + if start is None: start = 0 + elif start < 0: start += self._size + if stop is None: stop = self._size + elif stop < 0: stop += self._size + if step is None: step = 1 + return [self._get(self._ramp, i) for i in range(start, stop, step)] + else: + if indices < 0: + indices += self._size + return self._get(self._ramp, indices) + + def __setitem__(self, indices, values): + ''' + Modify the gamma ramp + + @param indices:slice The stops to modify + @param values:itr<int|float> The values for the selected stops + + -- OR -- + + @param indices:int The index of the stop to modify + @param values:int|float The new value for the stop + ''' + if isinstance(indices, slice): + start = indices.start + stop = indices.stop + step = indices.step + if start is None: start = 0 + elif start < 0: start += self._size + if stop is None: stop = self._size + elif stop < 0: stop += self._size + if step is None: step = 1 + indices = list(range(start, stop, step)) + if not len(indices) == len(values): + raise ValueError('cannot resize ramp') + for index, value in zip(indices, values): + self._set(self._ramp, index, value) + else: + if indices < 0: + indices += self._size + self._set(self._ramp, indices, values) + + def __iter__(self) -> iter: + ''' + Read the gamma ramp + + @return :itr<int|float> The values of each stop + ''' + for value in self[:]: + yield value + + def map(self, function): + ''' + Modify the entire ramp using a function that + maps encoding value to output value + + @param function:(float)→int|float Function that takes the encoding value as a + [0, 1] floating point and returns its output + value as the format using in the gamma ramp + ''' + max_i = self._size - 1 + for i in range(self._size): + self._set(self._ramp, i, function(i / max_i)) + + + def __init__(self, red_size : int, green_size : int = ..., blue_size : int = ..., *, depth : int = 16): + ''' + Constructor + + @param red_size The number of stops in the gamma ramp for the red channel + @param green_size The number of stops in the gamma ramp for the green channel, `...` for `red_size` + @param blue_size The number of stops in the gamma ramp for the blue channel, `...` for `green_size` + @param depth The depth of the gamma ramps + ''' + if green_size is ...: green_size = red_size + if blue_size is ...: blue_size = green_size + + self._depth = depth + + from libgamma_native_method import libgamma_native_gamma_ramps8_create + from libgamma_native_method import libgamma_native_gamma_ramps16_create + from libgamma_native_method import libgamma_native_gamma_ramps32_create + from libgamma_native_method import libgamma_native_gamma_ramps64_create + from libgamma_native_method import libgamma_native_gamma_rampsf_create + from libgamma_native_method import libgamma_native_gamma_rampsd_create + if depth == 8: ramp_struct = libgamma_native_gamma_ramps8_create (red_size, green_size, blue_size) + elif depth == 16: ramp_struct = libgamma_native_gamma_ramps16_create(red_size, green_size, blue_size) + elif depth == 32: ramp_struct = libgamma_native_gamma_ramps32_create(red_size, green_size, blue_size) + elif depth == 64: ramp_struct = libgamma_native_gamma_ramps64_create(red_size, green_size, blue_size) + elif depth == -1: ramp_struct = libgamma_native_gamma_rampsf_create (red_size, green_size, blue_size) + elif depth == -2: ramp_struct = libgamma_native_gamma_rampsd_create (red_size, green_size, blue_size) + else: + raise ValueError('invalid gamma ramp depth') + if isinstance(ramp_struct, int): + import libgamma_native_error as c + error = OSError() + error.errno = ramp_struct + error.strerror = c.strerror(error.errno) + raise error + (self._ramps, red, green, blue) = ramp_struct + + self._red = GammaRamps.Ramp(red, red_size, depth) + self._green = GammaRamps.Ramp(green, green_size, depth) + self._blue = GammaRamps.Ramp(blue, blue_size, depth) + + + def __del__(self): + ''' + This function is called when the object is not longer in use + ''' + from libgamma_native_method import libgamma_native_gamma_ramps8_free + from libgamma_native_method import libgamma_native_gamma_ramps16_free + from libgamma_native_method import libgamma_native_gamma_ramps32_free + from libgamma_native_method import libgamma_native_gamma_ramps64_free + from libgamma_native_method import libgamma_native_gamma_rampsf_free + from libgamma_native_method import libgamma_native_gamma_rampsd_free + if self._ramps == 0: + return + if self._depth == 8: libgamma_native_gamma_ramps8_free(self._ramps) + elif self._depth == 16: libgamma_native_gamma_ramps16_free(self._ramps) + elif self._depth == 32: libgamma_native_gamma_ramps32_free(self._ramps) + elif self._depth == 64: libgamma_native_gamma_ramps64_free(self._ramps) + elif self._depth == -1: libgamma_native_gamma_rampsf_free(self._ramps) + elif self._depth == -2: libgamma_native_gamma_rampsd_free(self._ramps) + + + @property + def red(self) -> Ramp: + ''' + Get the gamma ramp for the red channel + + @return The gamma ramp for the red channel + ''' + return self._red + + + @red.setter + def red(self, value): + ''' + It is not possible to change this attribute, but a setter is + required for the getter to function + ''' + raise AttributeError('cannot change ramps') + + + @property + def green(self) -> Ramp: + ''' + Get the gamma ramp for the green channel + + @return The gamma ramp for the green channel + ''' + return self._green + + + @green.setter + def green(self, value) -> Ramp: + ''' + It is not possible to change this attribute, but a setter is + required for the getter to function + ''' + raise AttributeError('cannot change ramps') + + + @property + def blue(self): + ''' + Get the gamma ramp for the blue channel + + @return The gamma ramp for the blue channel + ''' + return self._blue + + + @blue.setter + def blue(self, value): + ''' + It is not possible to change this attribute, but a setter is + required for the getter to function + ''' + raise AttributeError('cannot change ramps') + + + @property + def size(self) -> tuple: + ''' + Get the ramps' sizes + + @return :(red:int, green:int, blue:int) The size of each individual ramp + ''' + return (self._red.size, self._green.size, self._blue.size) + + + @size.setter + def size(self, value): + ''' + It is not possible to change this attribute, but a setter is + required for the getter to function + ''' + raise AttributeError('cannot resize ramps') + + + @property + def depth(self) -> int: + ''' + Get the depth of ramps + + @return :int The ramps' depth in bits and -1 for single precision floating + point and -2 for doublesingle precision floating point + ''' + return self._depth + + + @depth.setter + def depth(self, value): + ''' + It is not possible to change this attribute, but a setter is + required for the getter to function + ''' + raise AttributeError('cannot change depth') + + +class Site: + ''' + 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. + + @variable method:int The adjustment method of the site + @variable site:str? The site identifier + @variable partitions_available:int The number of paritions available in the site + ''' + + def __init__(self, method : int, site : str = None): + ''' + Constructor + + @param method:int The adjustment method of the site + @param site:str? The site identifier + ''' + from libgamma_native_facade import libgamma_native_site_create + (self._state, n) = libgamma_native_site_create(method, site) + if self._state == 0: + raise create_error(n) + self.partitions_available = n + self.method = method + self.site = site + + + def __del__(self): + ''' + This function is called when the object is not longer in use + ''' + from libgamma_native_facade import libgamma_native_site_free + if not self._state == 0: + libgamma_native_site_free(self._state) + + + def restore(self): + ''' + Restore the gamma ramps all CRTC:s with the site to the system settings + ''' + from libgamma_native_facade import libgamma_native_site_restore + r = libgamma_native_site_restore(self._state) + if not r == 0: + raise create_error(r) + + +class Partition: + ''' + 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 + + @variable site:Site The site of the partition + @variable partition:int The index of the partition + @variable crtcs_available:int The number of CRTC:s available in the parition + ''' + + def __init__(self, site : Site, partition : int): + ''' + Constructor. + + @param site The site of the partition + @param partition The index of the partition + ''' + from libgamma_native_facade import libgamma_native_partition_create + (self._state, n) = libgamma_native_partition_create(site._state, partition) + if self._state == 0: + raise create_error(n) + self.crtcs_available = n + self.site = site + self.partition = partition + + + def __del__(self): + ''' + This function is called when the object is not longer in use + ''' + from libgamma_native_facade import libgamma_native_partition_free + if not self._state == 0: + libgamma_native_partition_free(self._state) + + + def restore(self): + ''' + Restore the gamma ramps all CRTC:s with the partition to the system settings + ''' + from libgamma_native_facade import libgamma_native_partition_restore + r = libgamma_native_partition_restore(self._state) + if not r == 0: + raise create_error(r) + + +class CRTC: + ''' + 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 + + @variable partition:Partition The partition of the CRTC + @variable crtc:int The index of the CRTC + ''' + + def __init__(self, partition : Partition, crtc : int): + ''' + Constructor + + @param partition The partition the of the CRTC + @param crtc The index of the CRTC + ''' + from libgamma_native_facade import libgamma_native_crtc_create + (self._state, n) = libgamma_native_crtc_create(partition._state, crtc) + if self._state == 0: + raise create_error(n) + self.partition = partition + self.crtc = crtc + + + def __del__(self): + ''' + This function is called when the object is not longer in use + ''' + from libgamma_native_facade import libgamma_native_crtc_free + if not self._state == 0: + libgamma_native_crtc_free(self._state) + + + def restore(self): + ''' + Restore the gamma ramps for a CRTC to the system settings for that CRTC + ''' + from libgamma_native_facade import libgamma_native_crtc_restore + r = libgamma_native_crtc_restore(self._state) + if not r == 0: + raise create_error(r) + + + def information(self, fields : int) -> tuple: + ''' + Read information about a CRTC + + @param field OR:ed identifiers for the information + about the CRTC that should be read + @return :(:CRTCInformation, :bool) The information about the CRTC and + whether no errors occurred + ''' + from libgamma_native_facade import libgamma_native_get_crtc_information + (data, e) = libgamma_native_get_crtc_information(self._state, fields) + return (CRTCInformation(data), e == 0) + + + def get_gamma(self, ramps : GammaRamps): + ''' + Get the current gamma ramps for the CRTC + + @param ramps The gamma ramps to fill with the current values + ''' + from libgamma_native_facade import libgamma_native_crtc_get_gamma_ramps8 + from libgamma_native_facade import libgamma_native_crtc_get_gamma_ramps16 + from libgamma_native_facade import libgamma_native_crtc_get_gamma_ramps32 + from libgamma_native_facade import libgamma_native_crtc_get_gamma_ramps64 + from libgamma_native_facade import libgamma_native_crtc_get_gamma_rampsf + from libgamma_native_facade import libgamma_native_crtc_get_gamma_rampsd + if ramps.depth == 8: r = libgamma_native_crtc_get_gamma_ramps8(self._state, ramps._ramps) + elif ramps.depth == 16: r = libgamma_native_crtc_get_gamma_ramps16(self._state, ramps._ramps) + elif ramps.depth == 32: r = libgamma_native_crtc_get_gamma_ramps32(self._state, ramps._ramps) + elif ramps.depth == 64: r = libgamma_native_crtc_get_gamma_ramps64(self._state, ramps._ramps) + elif ramps.depth == -1: r = libgamma_native_crtc_get_gamma_rampsf(self._state, ramps._ramps) + elif ramps.depth == -2: r = libgamma_native_crtc_get_gamma_rampsd(self._state, ramps._ramps) + if not r == 0: + raise create_error(r) + + + def set_gamma(self, ramps : GammaRamps): + ''' + Set gamma ramps for the CRTC + + @param ramps The gamma ramps to apply + ''' + from libgamma_native_facade import libgamma_native_crtc_set_gamma_ramps8 + from libgamma_native_facade import libgamma_native_crtc_set_gamma_ramps16 + from libgamma_native_facade import libgamma_native_crtc_set_gamma_ramps32 + from libgamma_native_facade import libgamma_native_crtc_set_gamma_ramps64 + from libgamma_native_facade import libgamma_native_crtc_set_gamma_rampsf + from libgamma_native_facade import libgamma_native_crtc_set_gamma_rampsd + if ramps.depth == 8: r = libgamma_native_crtc_set_gamma_ramps8(self._state, ramps._ramps) + elif ramps.depth == 16: r = libgamma_native_crtc_set_gamma_ramps16(self._state, ramps._ramps) + elif ramps.depth == 32: r = libgamma_native_crtc_set_gamma_ramps32(self._state, ramps._ramps) + elif ramps.depth == 64: r = libgamma_native_crtc_set_gamma_ramps64(self._state, ramps._ramps) + elif ramps.depth == -1: r = libgamma_native_crtc_set_gamma_rampsf(self._state, ramps._ramps) + elif ramps.depth == -2: r = libgamma_native_crtc_set_gamma_rampsd(self._state, ramps._ramps) + if not r == 0: + raise create_error(r) |