Change license, flat file hier, do not use gpp, join .py and .pyx, simpler makefile1.1.2

Signed-off-by: Mattias Andrée <maandree@kth.se>

4 files changed, 0 insertions, 3507 deletions

diff --git a/src/include-libcoopgamma.h b/src/include-libcoopgamma.h
deleted file mode 100644
index 5150bf3..0000000
--- a/src/include-libcoopgamma.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * pylibcoopgamma -- Python library for interfacing with cooperative gamma servers
- * Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
- * 
- * 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/>.
- */
-#include <libcoopgamma.h>
-
-
-#define fclass        class
-#define u_red_size    u8.red_size
-#define u_green_size  u8.green_size
-#define u_blue_size   u8.blue_size
-#define u_red         u8.red
-#define u_green       u8.green
-#define u_blue        u8.blue
-
diff --git a/src/libcoopgamma.py b/src/libcoopgamma.py
deleted file mode 100644
index 37856c1..0000000
--- a/src/libcoopgamma.py
+++ /dev/null
@@ -1,1205 +0,0 @@
-# -*- python -*-
-'''
-pylibcoopgamma -- Python library for interfacing with cooperative gamma servers
-Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
-
-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/>.
-'''
-
-import enum, libcoopgamma_native
-
-
-class Support(enum.IntEnum):
-    '''
-    Values used to indicate the support for gamma adjustments
-    
-    @value  NO=0     Gamma adjustments are not supported
-    @value  MAYBE=1  Don't know whether gamma adjustments are supported
-    @value  YES=2    Gamma adjustments are supported
-    '''
-    NO = 0
-    MAYBE = 1
-    YES = 2
-    
-    @staticmethod
-    def str(v):
-        '''
-        Get string representation of a value
-        
-        @param   v:int  The value, must be value of the enum
-        @return  :str   Human-readable string representation of the value
-        '''
-        if v == Support.NO:
-            return 'no'
-        if v == Support.YES:
-            return 'yes'
-        if v == Support.MAYBE:
-            return 'maybe'
-        raise ValueError()
-
-
-class Depth(enum.IntEnum):
-    '''
-    Values used to tell which datatype is used for the gamma ramp stops
-    
-    The values will always be the number of bits for integral types, and
-    negative for floating-point types
-    
-    @value  UINT8=8    Unsigned 8-bit integer
-    @value  UINT16=16  Unsigned 16-bit integer
-    @value  UINT32=32  Unsigned 32-bit integer
-    @value  UINT64=64  Unsigned 64-bit integer
-    @value  FLOAT<0    Single-precision floating-point
-    @value  DOUBLE<0   Double-precision floating-point
-    '''
-    UINT8 = 8
-    UINT16 = 16
-    UINT32 = 32
-    UINT64 = 64
-    FLOAT = -1
-    DOUBLE = -2
-    
-    @staticmethod
-    def str(v):
-        '''
-        Get string representation of a value
-        
-        @param   v:int  The value, must be value of the enum
-        @return  :str   Human-readable string representation of the value
-        '''
-        if v == Depth.UINT8:
-            return '8-bits'
-        if v == Depth.UINT16:
-            return '16-bits'
-        if v == Depth.UINT32:
-            return '32-bits'
-        if v == Depth.UINT64:
-            return '64-bits'
-        if v == Depth.FLOAT:
-            return 'single-precision floating-point'
-        if v == Depth.DOUBLE:
-            return 'double-precision floating-point'
-        raise ValueError()
-
-
-class Lifespan(enum.IntEnum):
-    '''
-    Values used to tell when a filter should be removed
-    
-    @value  REMOVE=0         Remove the filter now
-    @value  UNTIL_DEATH>0    Remove the filter when disconnecting from the coopgamma server
-    @value  UNTIL_REMOVAL>0  Only remove the filter when it is explicitly requested
-    '''
-    REMOVE = 0
-    UNTIL_DEATH = 1
-    UNTIL_REMOVAL = 2
-    
-    @staticmethod
-    def str(v):
-        '''
-        Get string representation of a value
-        
-        @param   v:int  The value, must be value of the enum
-        @return  :str   Human-readable string representation of the value
-        '''
-        if v == Lifespan.REMOVE:
-            return 'remove'
-        if v == Lifespan.UNTIL_DEATH:
-            return 'until death'
-        if v == Lifespan.UNTIL_REMOVAL:
-            return 'until removal'
-        raise ValueError()
-
-
-class Colourspace(enum.IntEnum):
-    '''
-    Colourspaces
-    
-    @value  UNKNOWN=0  The colourspace is unknown
-    @value  SRGB>0     sRGB (Standard RGB)
-    @value  RGB>0      RGB other than sRGB
-    @value  NON_RGB>0  Non-RGB multicolour
-    @value  GREY>0     Monochrome, greyscale, or some other singlecolour scale
-    '''
-    UNKNOWN = 0
-    SRGB = 1
-    RGB = 2
-    NON_RGB = 3
-    GREY = 4
-    
-    @staticmethod
-    def str(v):
-        '''
-        Get string representation of a value
-        
-        @param   v:int  The value, must be value of the enum
-        @return  :str   Human-readable string representation of the value
-        '''
-        if v == Colourspace.UNKNOWN:
-            return 'unknown'
-        if v == Colourspace.SRGB:
-            return 'sRGB'
-        if v == Colourspace.RGB:
-            return 'RGB'
-        if v == Colourspace.NON_RGB:
-            return 'non-RGB'
-        if v == Colourspace.GREY:
-            return 'greyscale'
-        raise ValueError()
-
-
-class Ramps:
-    '''
-    Gamma ramp structure
-    
-    @variable  red:list<int>    The red gamma ramp
-    @variable  green:list<int>  The green gamma ramp
-    @variable  blue:list<int>   The blue gamma ramp
-    '''
-    def __init__(self, red, green, blue):
-        '''
-        Constructor
-        
-        @param  red:int    The number of stops in the red ramp
-        @param  green:int  The number of stops in the green ramp
-        @param  blue:int   The number of stops in the blue ramp
-        
-        -- or --
-        
-        @param  red:list<int>    The red gamma ramp
-        @param  green:list<int>  The green gamma ramp
-        @param  blue:list<int>   The blue gamma ramp
-        '''
-        if isinstance(red, list):
-            self.red   = list(red)
-            self.green = list(green)
-            self.blue  = list(blue)
-        else:
-            self.red   = [0] * red
-            self.green = [0] * green
-            self.blue  = [0] * blue
-    
-    def clone(self):
-        '''
-        Create a copy of the instance
-        '''
-        return Ramps(self.red, self.green, self.blue)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.red, self.green, self.blue)
-        return 'libcoopgamma.Ramps(%s)' % ', '.join(repr(p) for p in params)
-
-
-class Filter:
-    '''
-    Data set to the coopgamma server to apply, update, or remove a filter
-    
-    @variable  priority:int       The priority of the filter, higher priority
-                                  is applied first. The gamma correction should
-                                  have priority 0. This is a signed 64-bit integer.
-    @variable  crtc:str           The CRTC for which this filter shall be applied 
-    @variable  fclass:str         Identifier for the filter.
-                                  The syntax must be "${PACKAGE_NAME}::${COMMAND_NAME}::${RULE}".
-    @variable  lifespan:Lifespan  When shall the filter be removed?
-                                  If this member's value is `LIBCOOPGAMMA_REMOVE`,
-                                  only `.crtc` and `.class` need also be defined.
-    @variable  depth:Depth        The data type and bit-depth of the ramp stops
-    @variable  ramps:Ramps        The gamma ramp adjustments of the filter
-    '''
-    def __init__(self, priority = None, crtc = None, fclass = None, lifespan = None, depth = None, ramps = None):
-        '''
-        Constructor
-        
-        @param  priority:int       The priority of the filter, higher priority
-                                   is applied first. The gamma correction should
-                                   have priority 0. This is a signed 64-bit integer.
-        @param  crtc:str           The CRTC for which this filter shall be applied 
-        @param  fclass:str         Identifier for the filter.
-                                   The syntax must be "${PACKAGE_NAME}::${COMMAND_NAME}::${RULE}".
-        @param  lifespan:Lifespan  When shall the filter be removed?
-                                   If this member's value is `LIBCOOPGAMMA_REMOVE`,
-                                   only `.crtc` and `.class` need also be defined.
-        @param  depth:Depth        The data type and bit-depth of the ramp stops
-        @param  ramps:Ramps        The gamma ramp adjustments of the filter
-        '''
-        self.priority = priority
-        self.crtc = crtc
-        self.fclass = fclass
-        self.lifespan = lifespan
-        self.depth = depth
-        self.ramps = ramps
-    
-    def clone(self, shallow = False):
-        '''
-        Create a copy of the instance
-        
-        @param  shallow:bool  Create a shallow copy?
-        '''
-        ramps = self.ramps if shallow else self.ramps.clone()
-        return Filter(self.priority, self.crtc, self.fclass, self.lifespan, self.depth, ramps)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.priority, self.crtc, self.fclass, self.lifespan, self.depth, self.ramps)
-        return 'libcoopgamma.Filter(%s)' % ', '.join(repr(p) for p in params)
-
-
-class GamutPoint:
-    '''
-    The x- and y-values (CIE xyY) of a colour
-    
-    @variable  x_raw:int  The x-value (CIE xyY) multiplied by 1024
-    @variable  y_raw:int  The y-value (CIE xyY) multiplied by 1024
-    @variable  x:int      The x-value (CIE xyY)
-    @variable  y:int      The y-value (CIE xyY)
-    '''
-    def __init__(self, x, y):
-        '''
-        Constructor
-        
-        @param  x:int  The x-value (CIE xyY) multiplied by 1024
-        @param  y:int  The y-value (CIE xyY) multiplied by 1024
-        '''
-        self.x_raw, self.x = x, x / 1024
-        self.y_raw, self.y = y, y / 1024
-    
-    def clone(self):
-        '''
-        Create a copy of the instance
-        '''
-        return GamutPoint(self.x_raw, self.y_raw)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.x_raw, self.y_raw)
-        return 'libcoopgamma.GamutPoint(%s)' % ', '.join(repr(p) for p in params)
-    
-    def __str__(self):
-        '''
-        Get human-readable string representation of instance
-        
-        @return  :str  Human-readable string representation of instance
-        '''
-        return '(%f, %f)' % (self.x, self.y)
-
-
-class Gamut:
-    '''
-    The values of the monitor's colour stimuli
-    
-    @variable  red:GamutPoint    The red stimuli
-    @variable  green:GamutPoint  The green stimuli
-    @variable  blue:GamutPoint   The blue stimuli
-    @variable  white:GamutPoint  The default whitepoint
-    '''
-    def __init__(self, red = None, green = None, blue = None, white = None):
-        '''
-        Constructor
-        
-        @param  red:GamutPoint|(int, int)    The red stimuli
-        @param  green:GamutPoint|(int, int)  The green stimuli
-        @param  blue:GamutPoint|(int, int)   The blue stimuli
-        @param  white:GamutPoint|(int, int)  The default whitepoint
-        '''
-        self.red   = GamutPoint(*red)   if isinstance(red,   tuple) else red
-        self.green = GamutPoint(*green) if isinstance(green, tuple) else green
-        self.blue  = GamutPoint(*blue)  if isinstance(blue,  tuple) else blue
-        self.white = GamutPoint(*white) if isinstance(white, tuple) else white
-    
-    def clone(self, shallow = True):
-        '''
-        Create a copy of the instance
-        
-        @param  shallow:bool  Create a shallow copy?
-        '''
-        if shallow:
-            return Gamut(self.red, self.green, self.blue, self.white)
-        return Gamut(self.red.clone(), self.green.clone(), self.blue.clone(), self.white.clone())
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (repr(self.red), repr(self.green), repr(self.blue), repr(self.white))
-        return 'libcoopgamma.Gamut(%s)' % ', '.join(repr(p) for p in params)
-
-
-class CRTCInfo:
-    '''
-    Gamma ramp meta information for a CRTC
-    
-    @variable  cooperative:bool         Is cooperative gamma server running?
-    @variable  depth:Depth?             The data type and bit-depth of the ramp stops
-    @variable  supported:Support        Is gamma adjustments supported on the CRTC?
-                                        If not, `depth`, `red_size`, `green_size`,
-                                        and `blue_size` are undefined
-    @variable  red_size:int?            The number of stops in the red ramp
-    @variable  green_size:int?          The number of stops in the green ramp
-    @variable  blue_size:int?           The number of stops in the blue ramp
-    @variable  colourspace:Colourspace  The monitor's colourspace
-    @variable  gamut:Gamut?             Measurements of the monitor's colourspace,
-                                        `None` if the this information is unavailable.
-                                        If this is not `None`, but the colourspace
-                                        is not RGB (or sRGB), there is something
-                                        wrong. Always check the colourspace.
-    '''
-    def __init__(self, cooperative = None, depth = None, supported = None, red_size = None,
-                 green_size = None, blue_size = None, colourspace = None, gamut = None):
-        '''
-        Constructor
-        
-        @param  cooperative:bool         Is cooperative gamma server running?
-        @param  depth:Depth?             The data type and bit-depth of the ramp stops
-        @param  supported:Support        Is gamma adjustments supported on the CRTC?
-                                         If not, `depth`, `red_size`, `green_size`,
-                                         and `blue_size` are undefined
-        @param  red_size:int?            The number of stops in the red ramp
-        @param  green_size:int?          The number of stops in the green ramp
-        @param  blue_size:int?           The number of stops in the blue ramp
-        @param  colourspace:Colourspace  The monitor's colourspace
-        @param  gamut:Gamut|tuple?       Measurements of the monitor's colourspace,
-                                         `None` if the this information is unavailable
-        '''
-        self.cooperative = cooperative
-        self.depth = depth
-        self.supported = supported
-        self.red_size = red_size
-        self.green_size = green_size
-        self.blue_size = blue_size
-        self.colourspace = colourspace
-        if gamut is None or isinstance(gamut, Gamut):
-            self.gamut = gamut
-        else:
-            self.gamut = Gamut(*gamut)
-    
-    def make_ramps(self):
-        '''
-        Construct a `Ramps` instances for this CRTC
-        
-        @return  :Ramps  An instance of `Ramps` with same a number of ramp stops
-                         matching this CRTC
-        '''
-        return Ramps(self.red_size, self.green_size, self.blue_size)
-    
-    def clone(self, shallow = True):
-        '''
-        Create a copy of the instance
-        
-        @param  shallow:bool  Create a shallow copy?
-        '''
-        return CRTCInfo(self.cooperative, self.depth, self.supported, self.red_size,
-                        self.green_size, self.blue_size, self.colourspace,
-                        self.gamut if shallow else self.gamut.clone())
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.cooperative, self.depth, self.supported, self.red_size,
-                  self.green_size, self.blue_size, self.colourspace, self.gamut)
-        return 'libcoopgamma.CRTCInfo(%s)' % ', '.join(repr(p) for p in params)
-
-
-class FilterQuery:
-    '''
-    Data sent to the coopgamma server when requestng the current filter table
-    
-    @variable  high_priority:int  Do no return filters with higher priority than
-                                  this value. This is a signed 64-bit integer.
-    @variable  low_priority:int   Do no return filters with lower priority than
-                                  this value. This is a signed 64-bit integer.
-    @variable  crtc:str           The CRTC for which the the current filters shall returned
-    @variable  coalesce:bool      Whether to coalesce all filters into one gamma ramp triplet
-    '''
-    def __init__(self, high_priority = 9223372036854775807,
-                 low_priority = -9223372036854775808, crtc = None, coalesce = False):
-        '''
-        Constructor
-        
-        @param  high_priority:int  Do no return filters with higher priority than
-                                   this value. This is a signed 64-bit integer.
-        @param  low_priority:int   Do no return filters with lower priority than
-                                   this value. This is a signed 64-bit integer.
-        @param  crtc:str           The CRTC for which the the current filters shall returned
-        @param  coalesce:bool      Whether to coalesce all filters into one gamma ramp triplet
-        '''
-        self.high_priority = high_priority
-        self.low_priority = low_priority
-        self.crtc = crtc
-        self.coalesce = coalesce
-    
-    def clone(self):
-        '''
-        Create a copy of the instance
-        '''
-        return FilterQuery(self.high_priority, self.low_priority, self.crtc, self.coalesce)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.high_priority, self.low_priority, self.crtc, self.coalesce)
-        return 'libcoopgamma.FilterQuery(%s)' % ', '.join(repr(p) for p in params)
-
-
-class QueriedFilter:
-    '''
-    Stripped down version of `Filter` which only contains the
-    information returned in response to "Command: get-gamma"
-    
-    @variable  priority:int  The filter's priority. This is a signed 64-bit integer.
-    @variable  fclass:str    The filter's class
-    @variable  ramps:Ramps   The gamma ramp adjustments of the filter
-    '''
-    def __init__(self, priority = None, fclass = None, ramps = None):
-        '''
-        Constructor
-        
-        @param  priority:int       The filter's priority. This is a signed 64-bit integer.
-        @param  fclass:str         The filter's class
-        @param  ramps:Ramps|tuple  The gamma ramp adjustments of the filter
-        '''
-        self.priority = priority
-        self.fclass = fclass
-        self.ramps = None
-        if ramps is not None:
-            self.ramps = Ramps(*ramps) if isinstance(ramps, tuple) else ramps
-    
-    def clone(self, shallow = False):
-        '''
-        Create a copy of the instance
-        
-        @param  shallow:bool  Create a sallow copy?
-        '''
-        ramps = self.ramps if shallow else self.ramps.clone()
-        return QueriedFilter(self.priority, self.fclass, ramps)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.priority, self.fclass, self.ramps)
-        return 'libcoopgamma.QueriedFilter(%s)' % ', '.join(repr(p) for p in params)
-
-
-class FilterTable:
-    '''
-    Response type for "Command: get-gamma": a list of applied filters
-    and meta-information that was necessary for decoding the response
-    
-    @variable  red_size:int                 The number of stops in the red ramp
-    @variable  green_size:int               The number of stops in the green ramp
-    @variable  blue_size:int                The number of stops in the blue ramp
-    @variable  depth:Depth                  The data type and bit-depth of the ramp stops
-    @variable  filters:list<QueriedFilter>  The filters, should be ordered by priority
-                                            in descending order, lest there is something
-                                            wrong with the coopgamma server.
-                                            If filter coalition was requested, there will
-                                            be exactly one filter and `filters[0].class`
-                                            and `filters[0].priority` are undefined.
-    '''
-    def __init__(self, red_size = None, green_size = None, blue_size = None, depth = None, filters = None):
-        '''
-        Constructor 
-        
-        @param  red_size:int                       The number of stops in the red ramp
-        @param  green_size:int                     The number of stops in the green ramp
-        @param  blue_size:int                      The number of stops in the blue ramp
-        @param  depth:Depth                        The data type and bit-depth of the ramp stops
-        @param  filters:list<QueriedFilter|tuple>  The filters, should be ordered by priority
-                                                   in descending order, lest there is something
-                                                   wrong with the coopgamma server.
-                                                   If filter coalition was requested, there will
-                                                   be exactly one filter and `filters[0].class`
-                                                   and `filters[0].priority` are undefined.
-        '''
-        self.red_size   = red_size
-        self.green_size = green_size
-        self.blue_size  = blue_size
-        self.depth      = depth
-        if filters is None:
-            self.filters
-        else:
-            self.filters    = list(QueriedFilter(*f) if isinstance(f, tuple) else f for f in filters)
-    
-    def make_ramps(self):
-        '''
-        Construct a `Ramps` instances for this CRTC
-        
-        @return  :Ramps  An instance of `Ramps` with same a number of ramp stops
-                         matching this CRTC
-        '''
-        return Ramps(self.red_size, self.green_size, self.blue_size)
-    
-    def clone(self, shallow = False):
-        '''
-        Create a copy of the instance
-        
-        @param  shallow:bool  Create a sallow copy?
-        '''
-        filters = list(self.filters) if shallow else [f.clone() for f in self.filters]
-        return FilterTable(self.red_size, self.green_size, self.blue_size, self.depth, filters)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.red_size, self.green_size, self.blue_size, self.depth, self.filters)
-        return 'libcoopgamma.FilterTable(%s)' % ', '.join(repr(p) for p in params)
-
-
-class ErrorReport:
-    '''
-    Error message from coopgamma server
-    
-    @variable  number:int        The error code. If `.custom` is false, 0 indicates success,
-                                 otherwise, 0 indicates that no error code has been assigned.
-    @variable  custom:bool       Is this a custom error?
-    @variable  server_side:bool  Did the error occur on the server-side?
-    @variable  description:str?  Error message, can be `None` if `custom` is false
-    '''
-    def __init__(self, number = None, custom = None, server_side = None, description = None):
-        '''
-        Constructor
-        
-        @param  number:int        The error code. If `.custom` is false, 0 indicates success,
-                                  otherwise, 0 indicates that no error code has been assigned.
-        @param  custom:bool       Is this a custom error?
-        @param  server_side:bool  Did the error occur on the server-side?
-        @param  description:str?  Error message, can be `None` if `custom` is false
-        '''
-        self.number = number
-        self.custom = custom
-        self.server_side = server_side
-        self.description = description
-    
-    def clone(self):
-        '''
-        Create a copy of the instance
-        '''
-        return ErrorReport(self.number, self.custom, self.server_side, self.description)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        params = (self.number, self.custom, self.server_side, self.description)
-        return 'libcoopgamma.ErrorReport(%s)' % ', '.join(repr(p) for p in params)
-    
-    @staticmethod
-    def create_error(error):
-        '''
-        Create an instance of a subclass of `Exception`
-        
-        @param  error  Error information
-        '''
-        if isinstance(error, int):
-            import os
-            return OSError(error, os.strerror(error))
-        error = ErrorReport(*error)
-        if not error.custom and not error.server_side:
-            import os
-            return OSError(error.number, os.strerror(error.number))
-        else:
-            return LibcoopgammaError(error)
-
-
-class LibcoopgammaError(Exception):
-    '''
-    libcoopgamma error class
-    
-    @variable  error:ErrorReport  Error information
-    '''
-    def __init__(self, error):
-        '''
-        Constructor
-        
-        @param  error:ErrorReport  Error information
-        '''
-        self.error = error
-    
-    def __str__(self):
-        '''
-        Return description and error number as a string
-        
-        @return  :str  Description and error number
-        '''
-        if self.error.description is not None:
-            if self.error.number != 0:
-                return '%s (#%i)' % (self.error.description, self.error.number)
-            else:
-                return '%s' % self.error.description
-        else:
-            return '#%i' % self.error.number
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        return 'libcoopgamma.LibcoopgammaError(%s)' % repr(self.error)
-
-
-class IncompatibleDowngradeError(Exception):
-    '''
-    Unmarshalled state from a newer version, that is not supported, of libcoopgamma
-    '''
-    def __init__(self):
-        '''
-        Constructor
-        '''
-        pass
-    
-    def __str__(self):
-        '''
-        Return descriptor of the error
-        
-        @return  :str  Descriptor of the error
-        '''
-        return 'Incompatible downgrade error'
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        return 'libcoopgamma.IncompatibleDowngradeError()'
-
-
-class IncompatibleUpgradeError(Exception):
-    '''
-    Unmarshalled state from an older version, that is no longer supported, of libcoopgamma
-    '''
-    def __init__(self):
-        '''
-        Constructor
-        '''
-        pass
-    
-    def __str__(self):
-        '''
-        Return descriptor of the error
-        
-        @return  :str  Descriptor of the error
-        '''
-        return 'Incompatible downgrade error'
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        return 'libcoopgamma.IncompatibleUpgradeErrorError()'
-
-
-class ServerInitialisationError(Exception):
-    '''
-    coopgamma server failed to initialise, reason unknown
-    '''
-    def __init__(self):
-        '''
-        Constructor
-        '''
-        pass
-    
-    def __str__(self):
-        '''
-        Return descriptor of the error
-        
-        @return  :str  Descriptor of the error
-        '''
-        return 'Server initialisation error'
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        return 'libcoopgamma.ServerInitialisationError()'
-
-
-class Context:
-    '''
-    Library state
-    
-    Use of this structure is not thread-safe, create
-    one instance per thread that uses this structure
-    
-    @variable  fd:int  File descriptor for the socket
-    '''
-    def __init__(self, fd = -1, buf = None):
-        '''
-        Constructor
-        
-        @param  fd:int      File descriptor for the socket
-        @param  buf:bytes?  Buffer to unmarshal
-        '''
-        self.address = None
-        self.fd = fd
-        if buf is None:
-            (successful, value) = libcoopgamma_native.libcoopgamma_native_context_create()
-            if not successful:
-                raise ErrorReport.create_error(value)
-        else:
-            (error, value) = libcoopgamma_native.libcoopgamma_native_context_unmarshal(buf)
-            if error < 0:
-                raise ErrorReport.create_error(value)
-            elif error == 1:
-                raise IncompatibleDowngradeError()
-            elif error == 2:
-                raise IncompatibleUpgradeError()
-        self.address = value
-    
-    def __del__(self):
-        '''
-        Destructor
-        '''
-        if self.address is not None:
-            libcoopgamma_native.libcoopgamma_native_context_free(self.address)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        data = libcoopgamma_native.libcoopgamma_native_context_marshal(self.address)
-        if isinstance(data, int):
-            raise ErrorReport.create_error(data)
-        params = (self.fd, data)
-        return 'libcoopgamma.Context(%s)' % ', '.join(repr(p) for p in params)
-    
-    def connect(self, method = None, site = None):
-        '''
-        Connect to a coopgamma server, and start it if necessary
-        
-        Use `del` keyword to disconnect
-        
-        SIGCHLD must not be ignored or blocked
-        
-        All other methods in this class requires that this
-        method has been called successfully
-        
-        @param  method:int|str?  The adjustment method, `None` for automatic
-        @param  site:str?        The site, `None` for automatic
-        '''
-        if method is not None and isinstance(method, int):
-            method = str(method)
-        (successful, value) = libcoopgamma_native.libcoopgamma_native_connect(method, site, self.address)
-        if not successful:
-            if value == 0:
-                raise ServerInitialisationError()
-            else:
-                raise ErrorReport.create_error(value)
-        self.fd = value
-    
-    def detach(self):
-        '''
-        After calling this function, communication with the
-        server is impossible, but the connection is not
-        closed and the when the instance is destroyed the
-        connection will remain
-        '''
-        libcoopgamma_native.libcoopgamma_native_context_set_fd(self.address, -1)
-    
-    def attach(self):
-        '''
-        Undoes the action of `detach`
-        '''
-        libcoopgamma_native.libcoopgamma_native_context_set_fd(self.address, self.fd)
-    
-    def set_nonbreaking(self, nonbreaking):
-        '''
-        By default communication is blocking, this function
-        can be used to switch between blocking and nonblocking
-        
-        After setting the communication to nonblocking, `flush`, `synchronise` and
-        and request-sending functions can fail with EAGAIN and EWOULDBLOCK. It is
-        safe to continue with `flush` (for `flush` it selfand equest-sending functions)
-        or `synchronise` just like EINTR failure.
-        
-        @param  nonblocking:bool  Nonblocking mode?
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_set_nonblocking(self.address, nonbreaking)
-        if error != 0:
-            raise ErrorReport.create_error(error)
-    
-    def flush(self):
-        '''
-        Send all pending outbound data
-        
-        If this function or another function that sends a request to the server fails
-        with EINTR, call this function to complete the transfer. The `async_ctx` parameter
-        will always be in a properly configured state if a function fails with EINTR.
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_flush(self.address)
-        if error != 0:
-            raise ErrorReport.create_error(error)
-    
-    def synchronise(self, pending):
-        '''
-        Wait for the next message to be received
-        
-        @param   pending:list<AsyncContext>  Information for each pending request
-        @return  :int?                       The index of the element in `pending` which corresponds
-                                             to the first inbound message, note that this only means
-                                             that the message is not for any of the other request,
-                                             if the message is corrupt any of the listed requests can
-                                             be selected even if it is not for any of the requests.
-                                             Functions that parse the message will detect such corruption.
-                                             `None` if the message is ignored, which happens if
-                                             corresponding AsyncContext is not listed.
-        '''
-        pending = [p.address for p in pending]
-        (successful, value) = libcoopgamma_native.libcoopgamma_native_synchronise(self.address, pending)
-        if not successful:
-            if value == 0:
-                return None
-            else:
-                raise ErrorReport.create_error(value)
-        else:
-            return value
-    
-    def skip_message(self):
-        '''
-        Tell the library that you will not be parsing a receive message
-        '''
-        libcoopgamma_native.libcoopgamma_native_skip_message(self.address)
-    
-    def get_crtcs_send(self, async_ctx):
-        '''
-        List all available CRTC:s, send request part
-        
-        @param  async_ctx:AsyncContext  Slot for information about the request that is
-                                        needed to identify and parse the response
-        '''
-        
-        error = libcoopgamma_native.libcoopgamma_native_get_crtcs_send(self.address, async_ctx.address)
-        if error != 0:
-            raise ErrorReport.create_error(error)
-    
-    def get_crtcs_recv(self, async_ctx):
-        '''
-        List all available CRTC:s, receive response part
-        
-        @param   async_ctx:AsyncContext  Information about the request
-        @return  :list<str>              A list of names. You should only free the outer
-                                         pointer, inner pointers are subpointers of the
-                                         outer pointer and cannot be freed.
-        '''
-        ret = libcoopgamma_native.libcoopgamma_native_get_crtcs_recv(self.address, async_ctx.address)
-        if isinstance(ret, int):
-            raise ErrorReport.create_error(ret)
-        return ret
-    
-    def get_crtcs_sync(self):
-        '''
-        List all available CRTC:s, synchronous version
-        
-        This is a synchronous request function, as such, you have to ensure that
-        communication is blocking (default), and that there are not asynchronous
-        requests waiting, it also means that EINTR:s are silently ignored and
-        there no wait to cancel the operation without disconnection from the server
-        
-        @return  :list<str>  A list of names. You should only free the outer pointer, inner
-                             pointers are subpointers of the outer pointer and cannot be freed.
-        '''
-        ret = libcoopgamma_native.libcoopgamma_native_get_crtcs_sync(self.address)
-        if isinstance(ret, int):
-            raise ErrorReport.create_error(ret)
-        return ret
-    
-    def get_gamma_info_send(self, crtc, async_ctx):
-        '''
-        Retrieve information about a CRTC:s gamma ramps, send request part
-        
-        @param  crtc:str                The name of the CRT
-        @param  async_ctx:AsyncContext  Slot for information about the request that is
-                                        needed to identify and parse the response
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_get_gamma_info_send(crtc, self.address, async_ctx.address)
-        if error != 0:
-            raise ErrorReport.create_error(error)
-    
-    def get_gamma_info_recv(self, async_ctx):
-        '''
-        Retrieve information about a CRTC:s gamma ramps, receive response part
-        
-        @param   async_ctx:AsyncContext  Information about the request
-        @return  :CRTCInfo               Information about the CRTC
-        '''
-        value = libcoopgamma_native.libcoopgamma_native_get_gamma_info_recv(self.address, async_ctx.address)
-        if isinstance(value, int):
-            raise ErrorReport.create_error(value)
-        (successful, value) = value
-        if not successful:
-            raise ErrorReport.create_error(value)
-        return CRTCInfo(*value)
-    
-    def get_gamma_info_sync(self, crtc):
-        '''
-        Retrieve information about a CRTC:s gamma ramps, synchronous version
-        
-        This is a synchronous request function, as such, you have to ensure that
-        communication is blocking (default), and that there are not asynchronous
-        requests waiting, it also means that EINTR:s are silently ignored and
-        there no wait to cancel the operation without disconnection from the server
-        
-        @param   crtc:str   The name of the CRT
-        @return  :CRTCInfo  Information about the CRTC
-        '''
-        value = libcoopgamma_native.libcoopgamma_native_get_gamma_info_sync(crtc, self.address)
-        if isinstance(value, int):
-            raise ErrorReport.create_error(value)
-        (successful, value) = value
-        if not successful:
-            raise ErrorReport.create_error(value)
-        return CRTCInfo(*value)
-    
-    def get_gamma_send(self, query, async_ctx):
-        '''
-        Retrieve the current gamma ramp adjustments, send request part
-        
-        @param  query:FilterQuery       The query to send
-        @param  async_ctx:AsyncContext  Slot for information about the request that is
-                                        needed to identify and parse the response
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_get_gamma_send(
-                                    query, self.address, async_ctx.address)
-        if error != 0:
-            raise ErrorReport.create_error(error)
-    
-    def get_gamma_recv(self, async_ctx):
-        '''
-        Retrieve the current gamma ramp adjustments, receive response part
-        
-        @param   async_ctx:AsyncContext  Information about the request
-        @return  :FilterTable            Filter table
-        '''
-        value = libcoopgamma_native.libcoopgamma_native_get_gamma_recv(self.address, async_ctx.address)
-        if isinstance(value, int):
-            raise ErrorReport.create_error(value)
-        (successful, value) = value
-        if not successful:
-            raise ErrorReport.create_error(value)
-        return FilterTable(*value)
-    
-    def get_gamma_sync(self, query):
-        '''
-        Retrieve the current gamma ramp adjustments, synchronous version
-        
-        This is a synchronous request function, as such, you have to ensure that
-        communication is blocking (default), and that there are not asynchronous
-        requests waiting, it also means that EINTR:s are silently ignored and
-        there no wait to cancel the operation without disconnection from the server
-        
-        @param   query:FilterQuery  The query to send
-        @return  :FilterTable       Filter table
-        '''
-        value = libcoopgamma_native.libcoopgamma_native_get_gamma_sync(query, self.address)
-        if isinstance(value, int):
-            raise ErrorReport.create_error(value)
-        (successful, value) = value
-        if not successful:
-            raise ErrorReport.create_error(value)
-        return FilterTable(*value)
-    
-    def set_gamma_send(self, filtr, async_ctx):
-        '''
-        Apply, update, or remove a gamma ramp adjustment, send request part
-        
-        @param  filtr:Filter            The filter to apply, update, or remove, gamma ramp
-                                        meta-data must match the CRTC's
-        @param  async_ctx:AsyncContext  Slot for information about the request that is
-                                        needed to identify and parse the response
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_set_gamma_send(filtr, self.address, async_ctx.address)
-        if error != 0:
-            raise ErrorReport.create_error(error)
-    
-    def set_gamma_recv(self, async_ctx):
-        '''
-        Apply, update, or remove a gamma ramp adjustment, receive response part
-        
-        @param  async_ctx:AsyncContext  Information about the request
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_set_gamma_recv(self.address, async_ctx.address)
-        if error is not None:
-            raise ErrorReport.create_error(error)
-    
-    def set_gamma_sync(self, filtr):
-        '''
-        Apply, update, or remove a gamma ramp adjustment, synchronous version
-        
-        This is a synchronous request function, as such, you have to ensure that
-        communication is blocking (default), and that there are not asynchronous
-        requests waiting, it also means that EINTR:s are silently ignored and
-        there no wait to cancel the operation without disconnection from the server
-        
-        @param   filtr:Filter  The filter to apply, update, or remove,
-                               gamma ramp meta-data must match the CRTC's
-        '''
-        error = libcoopgamma_native.libcoopgamma_native_set_gamma_sync(filtr, self.address)
-        if error is not None:
-            raise ErrorReport.create_error(error)
-
-
-class AsyncContext:
-    '''
-    Information necessary to identify and parse a response from the server
-    '''
-    def __init__(self, buf = None):
-        '''
-        Constructor
-        
-        @param  buf:bytes?  Buffer to unmarshal
-        '''
-        self.address = None
-        if buf is None:
-            (successful, value) = libcoopgamma_native.libcoopgamma_native_async_context_create()
-            if not successful:
-                raise ErrorReport.create_error(value)
-        else:
-            (error, value) = libcoopgamma_native.libcoopgamma_native_async_context_unmarshal(buf)
-            if error < 0:
-                raise ErrorReport.create_error(value)
-            elif error == 1:
-                raise IncompatibleDowngradeError()
-            elif error == 2:
-                raise IncompatibleUpgradeError()
-        self.address = value
-    
-    def __del__(self):
-        '''
-        Destructor
-        '''
-        if self.address is not None:
-            libcoopgamma_native.libcoopgamma_native_async_context_free(self.address)
-    
-    def __repr__(self):
-        '''
-        Create a parsable string representation of the instance
-        
-        @return  :str  Parsable representation of the instance
-        '''
-        data = libcoopgamma_native.libcoopgamma_native_async_context_marshal(self.address)
-        if isinstance(data, int):
-            raise ErrorReport.create_error(data)
-        return 'libcoopgamma.AsyncContext(%s)' % repr(data)
-
-
-def get_methods():
-    '''
-    List all recognised adjustment method
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @return  :list<str>  A list of names. You should only free the outer pointer, inner
-                         pointers are subpointers of the outer pointer and cannot be freed.
-    '''
-    ret = libcoopgamma_native.libcoopgamma_native_get_methods()
-    if isinstance(ret, int):
-        raise ErrorReport.create_error(ret)
-    return ret
-
-
-def get_method_and_site(method = None, site = None):
-    '''
-    Get the adjustment method and site
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:int|str?  The adjustment method, `None` for automatic
-    @param   site:str?        The site, `None` for automatic
-    @return  :(:str, :str?)   The selected adjustment method and the selected the
-                              selected site. If the adjustment method only supports
-                              one site or if `site` is `None` and no site can be
-                              selected automatically, the selected site (the second
-                              element in the returned tuple) will be `None`.
-    '''
-    if method is not None:
-        method = str(method)
-    ret = libcoopgamma_native.libcoopgamma_native_get_method_and_site(method, site)
-    if isinstance(ret, int):
-        raise ErrorReport.create_error(ret)
-    return ret
-
-
-def get_pid_file(method = None, site = None):
-    '''
-    Get the PID file of the coopgamma server
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:int|str?  The adjustment method, `None` for automatic
-    @param   site:str?        The site, `None` for automatic
-    @return  :str?            The pathname of the server's PID file.
-                              `None` if the server does not use PID files.
-    '''
-    if method is not None:
-        method = str(method)
-    ret = libcoopgamma_native.libcoopgamma_native_get_pid_file(method, site)
-    if ret is not None and isinstance(ret, int):
-        raise ErrorReport.create_error(ret)
-    return ret
-
-
-def get_socket_file(method = None, site = None):
-    '''
-    Get the socket file of the coopgamma server
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:int|str?  The adjustment method, `None` for automatic
-    @param   site:str?        The site, `None` for automatic
-    @return  :str?            The pathname of the server's socket, `None` if the server does have
-                              its own socket, which is the case when communicating with a server
-                              in a multi-server display server like mds
-    '''
-    if method is not None:
-        method = str(method)
-    ret = libcoopgamma_native.libcoopgamma_native_get_socket_file(method, site)
-    if ret is not None and isinstance(ret, int):
-        raise ErrorReport.create_error(ret)
-    return ret
-
diff --git a/src/libcoopgamma_native.pyx.gpp b/src/libcoopgamma_native.pyx.gpp
deleted file mode 100644
index eee05ec..0000000
--- a/src/libcoopgamma_native.pyx.gpp
+++ /dev/null
@@ -1,1898 +0,0 @@
-# -*- python -*-
-'''
-pylibcoopgamma -- Python library for interfacing with cooperative gamma servers
-Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
-
-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 calloc, malloc, free
-from libc.stdint cimport int64_t, uint8_t, uint16_t, uint32_t, uint64_t, intptr_t
-from libc.errno cimport errno
-
-
-
-ctypedef int libcoopgamma_support_t
-# Values used to indicate the support for gamma adjustments
-
-ctypedef int libcoopgamma_depth_t
-# Values used to tell which datatype is used for the gamma ramp stops
-# 
-# The values will always be the number of bits for integral types, and
-# negative for floating-point types
-
-ctypedef int libcoopgamma_lifespan_t
-# Values used to tell when a filter should be removed
-
-ctypedef int libcoopgamma_colourspace_t
-# Colourspaces
-
-
-
-cdef extern from "include-libcoopgamma.h":
-
-    ctypedef struct libcoopgamma_ramps_t:
-    # Gamma ramp structure
-        size_t u_red_size
-        # The number of stops in the red ramp
-        size_t u_green_size
-        # The number of stops in the green ramp
-        size_t u_blue_size
-        # The number of stops in the blue ramp
-        void* u_red
-        # The red ramp
-        void* u_green
-        # The green ramp
-        void* u_blue
-        # The blue ramp
-
-    ctypedef struct libcoopgamma_filter_t:
-    # Data set to the coopgamma server to apply, update, or remove a filter
-        int64_t priority
-        # The priority of the filter, higher priority is applied first.
-        # The gamma correction should have priority 0.
-        char* crtc
-        # The CRTC for which this filter shall be applied
-        char* fclass
-        # Identifier for the filter
-        # 
-        # The syntax must be "${PACKAGE_NAME}::${COMMAND_NAME}::${RULE}"
-        libcoopgamma_lifespan_t lifespan
-        # When shall the filter be removed?
-        # 
-        # If this member's value is `LIBCOOPGAMMA_REMOVE`,
-        # only `.crtc` and `.class` need also be defined
-        libcoopgamma_depth_t depth
-        # The data type and bit-depth of the ramp stops
-        libcoopgamma_ramps_t ramps
-        # The gamma ramp adjustments of the filter
-
-    ctypedef struct libcoopgamma_crtc_info_t:
-    # Gamma ramp meta information for a CRTC
-        int cooperative
-        # Is cooperative gamma server running?
-        libcoopgamma_depth_t depth
-        # Is gamma adjustments supported on the CRTC?
-        # If not, `.depth`, `.red_size`, `.green_size`,
-        # and `.blue_size` are undefined 
-        libcoopgamma_support_t supported
-        # The data type and bit-depth of the ramp stops
-$$<cpp <<EOF | tail -n 1 | sed '/#/d'
-#include <limits.h>
-#if INT_MAX != LONG_MAX
-        int padding__
-#endif
-EOF
-$$>
-        size_t red_size
-        # The number of stops in the red ramp
-        size_t green_size
-        # The number of stops in the green ramp
-        size_t blue_size
-        # The number of stops in the blue ramp
-        libcoopgamma_colourspace_t colourspace
-        # The monitor's colurspace
-        int have_gamut
-        # Whether `.red_x`, `.red_y`, `.green_x`, `.green_y`, `.blue_x`, `.blue_y`,
-        # `.white_x`, and `.white_y` are set.
-        # 
-        # If this is true, but the colourspace is not RGB (or sRGB),
-        # there is something wrong. Please also check the colourspace.
-        unsigned red_x
-        # The x-value (CIE xyY) of the monitor's red colour, multiplied by 1024
-        unsigned red_y
-        # The y-value (CIE xyY) of the monitor's red colour, multiplied by 1024
-        unsigned green_x
-        # The x-value (CIE xyY) of the monitor's green colour, multiplied by 1024
-        unsigned green_y
-        # The y-value (CIE xyY) of the monitor's green colour, multiplied by 1024
-        unsigned blue_x
-        # The x-value (CIE xyY) of the monitor's blue colour, multiplied by 1024
-        unsigned blue_y
-        # The y-value (CIE xyY) of the monitor's blue colour, multiplied by 1024
-        unsigned white_x
-        # The x-value (CIE xyY) of the monitor's default white point, multiplied by 1024
-        unsigned white_y
-        # The y-value (CIE xyY) of the monitor's default white point, multiplied by 1024
-
-    ctypedef struct libcoopgamma_filter_query_t:
-    # Data sent to the coopgamma server when requestng the current filter table
-        int64_t high_priority
-        # Do no return filters with higher priority than this value
-        int64_t low_priority
-        # Do no return filters with lower priority than this value
-        char* crtc
-        # The CRTC for which the the current filters shall returned
-        int coalesce
-        # Whether to coalesce all filters into one gamma ramp triplet
-$$<cpp <<EOF | tail -n 1 | sed '/#/d'
-#include <limits.h>
-#if INT_MAX != LONG_MAX
-        int padding__
-#endif
-EOF
-$$>
-
-    ctypedef struct libcoopgamma_queried_filter_t:
-    # Stripped down version of `libcoopgamma_filter` which only contains
-    # the information returned in response to "Command: get-gamma"
-        int64_t priority
-        # The filter's priority
-        char* fclass
-        # The filter's class
-        libcoopgamma_ramps_t ramps
-        # The gamma ramp adjustments of the filter
-
-    ctypedef struct libcoopgamma_filter_table_t:
-    # Response type for "Command: get-gamma": a list of applied filters
-    # and meta-information that was necessary for decoding the response
-        size_t red_size
-        # The number of stops in the red ramp
-        size_t green_size
-        # The number of stops in the green ramp
-        size_t blue_size
-        # The number of stops in the blue ramp
-        size_t filter_count
-        # The number of filters
-        libcoopgamma_queried_filter_t* filters
-        # The filters, should be ordered by priority in descending order,
-        # lest there is something wrong with the coopgamma server
-        # 
-        # If filter coalition was requested, there will be exactly one
-        # filter (`.filter_count == 1`) and `.filters->class == NULL`
-        # and `.filters->priority` is undefined.
-        libcoopgamma_depth_t depth
-        # The data type and bit-depth of the ramp stops
-$$<cpp <<EOF | tail -n 1 | sed '/#/d'
-#include <limits.h>
-#if INT_MAX != LONG_MAX
-        int padding__
-#endif
-EOF
-$$>
-
-    ctypedef struct libcoopgamma_error_t:
-    # Error message from coopgamma server
-        uint64_t number
-        # Error code
-        # 
-        # If `.custom` is false, 0 indicates success, otherwise,
-        # 0 indicates that no error code has been assigned
-        int custom
-        # Is this a custom error?
-        int server_side
-        # Did the error occur on the server-side?
-        char* description
-        # Error message, can be `NULL` if `.custom` is false
-
-    ctypedef struct libcoopgamma_context_t:
-    # Library state
-    # 
-    # Use of this structure is not thread-safe create one instance
-    # per thread that uses this structure
-        libcoopgamma_error_t error
-        # The error of the last failed function call
-        # 
-        # This member is undefined after successful function call
-        int fd
-        # File descriptor for the socket
-        int have_all_headers
-        # Whether `libcoopgamma_synchronise` have read the empty end-of-headers line
-        int bad_message
-        # Whether `libcoopgamma_synchronise` is reading a corrupt but recoverable message
-        int blocking
-        # Is communication blocking?
-        uint32_t message_id
-        # Message ID of the next message
-        uint32_t in_response_to
-        # The ID of outbound message to which the inbound message being read by
-        # `libcoopgamma_synchronise` is a response
-        char* outbound
-        # Buffer with the outbound message
-        size_t outbound_head
-        # The write head for `outbound`
-        size_t outbound_tail
-        # The read head for `outbound`
-        size_t outbound_size
-        # The allocation size of `outbound`
-        char* inbound
-        # Buffer with the inbound message
-        size_t inbound_head
-        # The write head for `inbound`
-        size_t inbound_tail
-        # The read head for `inbound`
-        size_t inbound_size
-        # The allocation size of `inbound`
-        size_t length
-        # The value of 'Length' header in the inbound message
-        size_t curline
-        # The beginning of the current line that is being read by `libcoopgamma_synchronise`
-
-    ctypedef struct libcoopgamma_async_context_t:
-    # Information necessary to identify and parse a response from the server
-        uint32_t message_id
-        # The value of the 'In response to' header in the waited message
-        int coalesce
-        # Whether to coalesce all filters into one gamma ramp triplet
-
-
-
-cdef extern int libcoopgamma_ramps_initialise_(libcoopgamma_ramps_t* this, size_t width) nogil
-'''
-Initialise a `libcoopgamma_ramps_t`
-
-`this->red_size`, `this->green_size`, and `this->blue_size` must already be set
-
-@param   this   The record to initialise
-@param   width  The `sizeof(*(this->red))`
-@return         Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_ramps_destroy(libcoopgamma_ramps_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_ramps_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_ramps_initialise
-or failed call to `libcoopgamma_ramps_unmarshal
-
-@param  this  The record to destroy
-'''
-
-cdef extern int libcoopgamma_filter_initialise(libcoopgamma_filter_t* this) nogil
-'''
-Initialise a `libcoopgamma_filter_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on err
-'''
-
-cdef extern void libcoopgamma_filter_destroy(libcoopgamma_filter_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_filter_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_filter_initialise`
-or failed call to `libcoopgamma_filter_unmarshal`
-
-@param  this  The record to destroy
-'''
-
-cdef extern int libcoopgamma_crtc_info_initialise(libcoopgamma_crtc_info_t* this) nogil
-'''
-Initialise a `libcoopgamma_crtc_info_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_crtc_info_destroy(libcoopgamma_crtc_info_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_crtc_info_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_crtc_info_initialise`
-or failed call to `libcoopgamma_crtc_info_unmarshal
-
-@param  this  The record to destroy
-'''
-
-cdef extern int libcoopgamma_filter_query_initialise(libcoopgamma_filter_query_t* this) nogil
-'''
-Initialise a `libcoopgamma_filter_query_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_filter_query_destroy(libcoopgamma_filter_query_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_filter_query_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_filter_query_initialise`
-or failed call to `libcoopgamma_filter_query_unmarshal`
-
-@param  this  The record to destroy
-'''
-
-cdef extern int libcoopgamma_queried_filter_initialise(libcoopgamma_queried_filter_t* this) nogil
-'''
-Initialise a `libcoopgamma_queried_filter_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_queried_filter_destroy(libcoopgamma_queried_filter_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_queried_filter_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_queried_filter_initialise`
-or failed call to `libcoopgamma_queried_filter_unmarshal
-
-@param  this  The record to destro
-'''
-
-cdef extern int libcoopgamma_filter_table_initialise(libcoopgamma_filter_table_t* this) nogil
-'''
-Initialise a `libcoopgamma_filter_table_t
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_filter_table_destroy(libcoopgamma_filter_table_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_filter_table_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_filter_table_initialise`
-or failed call to `libcoopgamma_filter_table_unmarshal`
-
-@param  this  The record to destroy
-'''
-
-cdef extern void libcoopgamma_filter_table_destroy(libcoopgamma_filter_table_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_filter_table_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_filter_table_initialise`
-or failed call to `libcoopgamma_filter_table_unmarshal`
-
-@param  this  The record to destroy
-'''
-
-cdef extern int libcoopgamma_error_initialise(libcoopgamma_error_t* this) nogil
-'''
-Initialise a `libcoopgamma_error_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_error_destroy(libcoopgamma_error_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_error_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_error_initialise`
-or failed call to `libcoopgamma_error_unmarshal`
-
-@param  this  The record to destroy
-'''
-
-cdef extern int libcoopgamma_context_initialise(libcoopgamma_context_t* this) nogil
-'''
-Initialise a `libcoopgamma_context_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_context_destroy(libcoopgamma_context_t* this, int disconnect) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_context_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_context_initialise`
-or failed call to `libcoopgamma_context_unmarshal`
-
-@param  this        The record to destroy
-@param  disconnect  Disconnect from the server?
-'''
-
-cdef extern size_t libcoopgamma_context_marshal(const libcoopgamma_context_t* this, void* buf) nogil
-'''
-Marshal a `libcoopgamma_context_t` into a buffer
-
-@param   this  The record to marshal
-@param   buf   The output buffer, `NULL` to only measure
-               how large this buffer has to be
-@return        The number of marshalled bytes, or if `buf == NULL`,
-               how many bytes would be marshalled if `buf != NULL`
-'''
-
-cdef extern int libcoopgamma_context_unmarshal(libcoopgamma_context_t* this, const void* buf, size_t* n) nogil
-'''
-Unmarshal a `libcoopgamma_context_t` from a buffer
-
-@param   this  The output parameter for unmarshalled record
-@param   buf   The buffer with the marshalled record
-@param   n     Output parameter for the number of unmarshalled bytes, undefined on failure
-@return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
-               `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
-'''
-
-cdef extern int libcoopgamma_async_context_initialise(libcoopgamma_async_context_t* this) nogil
-'''
-Initialise a `libcoopgamma_async_context_t`
-
-@param   this  The record to initialise
-@return        Zero on success, -1 on error
-'''
-
-cdef extern void libcoopgamma_async_context_destroy(libcoopgamma_async_context_t* this) nogil
-'''
-Release all resources allocated to  a `libcoopgamma_async_context_t`,
-the allocation of the record itself is not freed
-
-Always call this function after failed call to `libcoopgamma_async_context_initialise`
-or failed call to `libcoopgamma_async_context_unmarshal`
-
-@param  this  The record to destroy
-'''
-
-cdef extern size_t libcoopgamma_async_context_marshal(const libcoopgamma_async_context_t* this, void* buf) nogil
-'''
-Marshal a `libcoopgamma_async_context_t` into a buffer
-
-@param   this  The record to marshal
-@param   buf   The output buffer, `NULL` to only measure
-               how large this buffer has to be
-@return        The number of marshalled bytes, or if `buf == NULL`,
-               how many bytes would be marshalled if `buf != NULL`
-'''
-
-cdef extern int libcoopgamma_async_context_unmarshal(libcoopgamma_async_context_t* this,
-                                                     const void* buf, size_t* n) nogil
-'''
-Unmarshal a `libcoopgamma_async_context_t` from a buffer
-
-@param   this  The output parameter for unmarshalled record
-@param   buf   The buffer with the marshalled record
-@param   n     Output parameter for the number of unmarshalled bytes, undefined on failure
-@return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
-               `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
-'''
-
-cdef extern char** libcoopgamma_get_methods() nogil
-'''
-List all recognised adjustment method
-
-SIGCHLD must not be ignored or blocked
-
-@return  A `NULL`-terminated list of names. You should only free
-         the outer pointer, inner pointers are subpointers of the
-         outer pointer and cannot be freed. `NULL` on error.
-'''
-
-cdef extern int libcoopgamma_get_method_and_site(const char* method, const char* site,
-                                                 char** methodp, char** sitep) nogil
-'''
-Get the adjustment method and site
-
-SIGCHLD must not be ignored or blocked
-
-@param   method   The adjustment method, `NULL` for automatic
-@param   site     The site, `NULL` for automatic
-@param   methodp  Output pointer for the selected adjustment method,
-                  which cannot be `NULL`. It is safe to call
-                  this function with this parameter set to `NULL`.
-@param   sitep    Output pointer for the selected site, which will
-                  be `NULL` the method only supports one site or if
-                  `site == NULL` and no site can be selected
-                  automatically. It is safe to call this function
-                  with this parameter set to `NULL`.
-@return           Zero on success, -1 on error
-'''
-
-cdef extern char* libcoopgamma_get_pid_file(const char* method, const char* site) nogil
-'''
-Get the PID file of the coopgamma server
-
-SIGCHLD must not be ignored or blocked
-
-@param   method   The adjustment method, `NULL` for automatic
-@param   site     The site, `NULL` for automatic
-@return           The pathname of the server's PID file, `NULL` on error
-                  or if there server does not use PID files. The later
-                  case is detected by checking that `errno` is set to 0.
-'''
-
-cdef extern char* libcoopgamma_get_socket_file(const char* method, const char* site) nogil
-'''
-Get the socket file of the coopgamma server
-
-SIGCHLD must not be ignored or blocked
-
-@param   method   The adjustment method, `NULL` for automatic
-@param   site     The site, `NULL` for automatic
-@return           The pathname of the server's socket, `NULL` on error
-                  or if there server does have its own socket. The later
-                  case is detected by checking that `errno` is set to 0,
-                  and is the case when communicating with a server in a
-                  multi-server display server like mds.
-'''
-
-cdef extern int libcoopgamma_connect(const char* method, const char* site, libcoopgamma_context_t* ctx) nogil
-'''
-Connect to a coopgamma server, and start it if necessary
-
-Use `libcoopgamma_context_destroy` to disconnect
-
-SIGCHLD must not be ignored or blocked
-
-@param   method  The adjustment method, `NULL` for automatic
-@param   site    The site, `NULL` for automatic
-@param   ctx     The state of the library, must be initialised
-@return          Zero on success, -1 on error. On error, `errno` is set
-                 to 0 if the server could not be initialised.
-'''
-
-cdef extern int libcoopgamma_set_nonblocking(libcoopgamma_context_t* ctx, int nonblocking) nogil
-'''
-By default communication is blocking, this function
-can be used to switch between blocking and nonblocking
-
-After setting the communication to nonblocking,
-`libcoopgamma_flush`, `libcoopgamma_synchronise` and
-and request-sending functions can fail with EAGAIN and
-EWOULDBLOCK. It is safe to continue with `libcoopgamma_flush`
-(for `libcoopgamma_flush` it selfand equest-sending functions)
-or `libcoopgamma_synchronise` just like EINTR failure.
-
-@param   ctx          The state of the library, must be connected
-@param   nonblocking  Nonblocking mode?
-@return               Zero on success, -1 on error
-'''
-
-cdef extern int libcoopgamma_flush(libcoopgamma_context_t* ctx) nogil
-'''
-Send all pending outbound data
-
-If this function or another function that sends a request
-to the server fails with EINTR, call this function to
-complete the transfer. The `async_ctx` parameter will always
-be in a properly configured state if a function fails
-with EINTR.
-
-@param   ctx  The state of the library, must be connected
-@return       Zero on success, -1 on error
-'''
-
-cdef extern int libcoopgamma_synchronise(libcoopgamma_context_t* ctx, libcoopgamma_async_context_t* pending,
-                                         size_t n, size_t* selected) nogil
-'''
-Wait for the next message to be received
-
-@param   ctx       The state of the library, must be connected
-@param   pending   Information for each pending request
-@param   n         The number of elements in `pending`
-@param   selected  The index of the element in `pending` which corresponds
-                   to the first inbound message, note that this only means
-                   that the message is not for any of the other request,
-                   if the message is corrupt any of the listed requests can
-                   be selected even if it is not for any of the requests.
-                   Functions that parse the message will detect such corruption.
-@return            Zero on success, -1 on error. If the the message is ignored,
-                   which happens if corresponding `libcoopgamma_async_context_t`
-                   is not listed, -1 is returned and `errno` is set to 0. If -1
-                   is returned, `errno` is set to `ENOTRECOVERABLE` you have
-                   received a corrupt message and the context has been tainted
-                   beyond recover.
-'''
-
-cdef extern void libcoopgamma_skip_message(libcoopgamma_context_t* ctx) nogil
-'''
-Tell the library that you will not be parsing a receive message
-
-@param  ctx  The state of the library, must be connected
-'''
-
-cdef extern int libcoopgamma_get_crtcs_send(libcoopgamma_context_t* ctx, libcoopgamma_async_context_t* async_ctx) nogil
-'''
-List all available CRTC:s, send request part
-
-Cannot be used before connecting to the server
-
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request, that is needed to
-                    identify and parse the response, is stored here
-@return             Zero on success, -1 on error
-'''
-
-cdef extern char** libcoopgamma_get_crtcs_recv(libcoopgamma_context_t* ctx, libcoopgamma_async_context_t* async_ctx) nogil
-'''
-List all available CRTC:s, receive response part
-
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request
-@return             A `NULL`-terminated list of names. You should only free
-                    the outer pointer, inner pointers are subpointers of the
-                    outer pointer and cannot be freed. `NULL` on error, in
-                    which case `ctx->error` (rather than `errno`) is read
-                    for information about the error.
-'''
-
-cdef extern char** libcoopgamma_get_crtcs_sync(libcoopgamma_context_t* ctx) nogil
-'''
-List all available CRTC:s, synchronous version
-
-This is a synchronous request function, as such,
-you have to ensure that communication is blocking
-(default), and that there are not asynchronous
-requests waiting, it also means that EINTR:s are
-silently ignored and there no wait to cancel the
-operation without disconnection from the server
-
-@param   ctx  The state of the library, must be connected
-@return       A `NULL`-terminated list of names. You should only free
-              the outer pointer, inner pointers are subpointers of the
-              outer pointer and cannot be freed. `NULL` on error, in
-              which case `ctx->error` (rather than `errno`) is read
-              for information about the error.
-'''
-
-cdef extern int libcoopgamma_get_gamma_info_send(const char* crtc, libcoopgamma_context_t* ctx,
-                                                 libcoopgamma_async_context_t* async_ctx) nogil
-'''
-Retrieve information about a CRTC:s gamma ramps, send request part
-
-Cannot be used before connecting to the server
-
-@param   crtc       The name of the CRTC
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request, that is needed to
-                    identify and parse the response, is stored here
-@return             Zero on success, -1 on error
-'''
-
-cdef extern int libcoopgamma_get_gamma_info_recv(libcoopgamma_crtc_info_t* info, libcoopgamma_context_t* ctx,
-                                                 libcoopgamma_async_context_t* async_ctx) nogil
-'''
-Retrieve information about a CRTC:s gamma ramps, receive response part
-
-@param   info       Output parameter for the information, must be initialised
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request
-@return             Zero on success, -1 on error, in which case `ctx->error`
-                    (rather than `errno`) is read for information about the error
-'''
-
-cdef extern int libcoopgamma_get_gamma_info_sync(const char* crtc, libcoopgamma_crtc_info_t* info,
-                                                 libcoopgamma_context_t* ctx) nogil
-'''
-Retrieve information about a CRTC:s gamma ramps, synchronous version
-
-This is a synchronous request function, as such,
-you have to ensure that communication is blocking
-(default), and that there are not asynchronous
-requests waiting, it also means that EINTR:s are
-silently ignored and there no wait to cancel the
-operation without disconnection from the server
-
-@param   crtc   The name of the CRTC
-@param   info   Output parameter for the information, must be initialised
-@param   ctx    The state of the library, must be connected
-@return         Zero on success, -1 on error, in which case `ctx->error`
-                (rather than `errno`) is read for information about the error
-'''
-
-cdef extern int libcoopgamma_get_gamma_send(const libcoopgamma_filter_query_t* query,
-                                            libcoopgamma_context_t* ctx, libcoopgamma_async_context_t* async_ctx) nogil
-'''
-Retrieve the current gamma ramp adjustments, send request part
-
-Cannot be used before connecting to the server
-
-@param   query      The query to send
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request, that is needed to
-                    identify and parse the response, is stored here
-@return             Zero on success, -1 on error
-'''
-
-cdef extern int libcoopgamma_get_gamma_recv(libcoopgamma_filter_table_t* table, libcoopgamma_context_t* ctx,
-                                            libcoopgamma_async_context_t* async_ctx) nogil
-'''
-Retrieve the current gamma ramp adjustments, receive response part
-
-@param   table      Output for the response, must be initialised
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request
-@return             Zero on success, -1 on error, in which case `ctx->error`
-                    (rather than `errno`) is read for information about the error
-'''
-
-cdef extern int libcoopgamma_get_gamma_sync(const libcoopgamma_filter_query_t* query,
-                                            libcoopgamma_filter_table_t* table, libcoopgamma_context_t* ctx) nogil
-'''
-Retrieve the current gamma ramp adjustments, synchronous version
-
-This is a synchronous request function, as such,
-you have to ensure that communication is blocking
-(default), and that there are not asynchronous
-requests waiting, it also means that EINTR:s are
-silently ignored and there no wait to cancel the
-operation without disconnection from the server
-
-@param   query  The query to send
-@param   table  Output for the response, must be initialised
-@param   ctx    The state of the library, must be connected
-@return         Zero on success, -1 on error, in which case `ctx->error`
-                (rather than `errno`) is read for information about the error
-'''
-
-cdef extern int libcoopgamma_set_gamma_send(const libcoopgamma_filter_t* filtr, libcoopgamma_context_t* ctx,
-                                            libcoopgamma_async_context_t* async_ctx) nogil
-'''
-Apply, update, or remove a gamma ramp adjustment, send request part
-
-Cannot be used before connecting to the server
-
-@param   filtr      The filter to apply, update, or remove, gamma ramp meta-data must match the CRTC's
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request, that is needed to
-                    identify and parse the response, is stored here
-@return             Zero on success, -1 on error
-'''
-
-cdef extern int libcoopgamma_set_gamma_recv(libcoopgamma_context_t* ctx, libcoopgamma_async_context_t* async_ctx) nogil
-'''
-Apply, update, or remove a gamma ramp adjustment, receive response part
-
-@param   ctx        The state of the library, must be connected
-@param   async_ctx  Information about the request
-@return             Zero on success, -1 on error, in which case `ctx->error`
-                    (rather than `errno`) is read for information about the error
-'''
-
-cdef extern int libcoopgamma_set_gamma_sync(const libcoopgamma_filter_t* filtr, libcoopgamma_context_t* ctx) nogil
-'''
-Apply, update, or remove a gamma ramp adjustment, synchronous version
-
-This is a synchronous request function, as such,
-you have to ensure that communication is blocking
-(default), and that there are not asynchronous
-requests waiting, it also means that EINTR:s are
-silently ignored and there no wait to cancel the
-operation without disconnection from the server
-
-@param   filtr  The filter to apply, update, or remove, gamma ramp meta-data must match the CRTC's
-@param   ctx    The state of the library, must be connected
-@return         Zero on success, -1 on error, in which case `ctx->error`
-                (rather than `errno`) is read for information about the error
-'''
-
-
-
-def libcoopgamma_native_get_methods():
-    '''
-    List all recognised adjustment method
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @return  :list<str>|int  Either the value of `errno` (on failure), or (on success) a list
-                             of names. You should only free the outer pointer, inner pointers
-                             are subpointers of the outer pointer and cannot be freed.
-    '''
-    cdef char** methods = libcoopgamma_get_methods()
-    cdef bytes bs
-    if methods is NULL:
-        return int(errno)
-    try:
-        ret = []
-        i = 0
-        while methods[i] is not NULL:
-            bs = methods[i]
-            ret.append(bs.decode('utf-8', 'strict'))
-            i += 1
-    finally:
-        free(methods)
-    return ret
-
-
-def libcoopgamma_native_get_method_and_site(method : str, site : str):
-    '''
-    Get the adjustment method and site
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:str?         The adjustment method, `None` for automatic
-    @param   site:str?           The site, `None` for automatic
-    @return  :int|(:str, :str?)  Either the value of `errno` (on failure), or (on success)
-                                 the selected adjustment method and the selected the
-                                 selected site. If the adjustment method only supports
-                                 one site or if `site` is `None` and no site can be
-                                 selected automatically, the selected site (the second
-                                 element in the returned tuple) will be `None`.
-    '''
-    cdef char* cmethod = NULL
-    cdef char* csite = NULL
-    cdef char* rcsmethod = NULL
-    cdef char* rcssite = NULL
-    cdef bytes rbsmethod
-    cdef bytes rbssite
-    try:
-        if method is not None:
-            buf = method.encode('utf-8') + bytes([0])
-            cmethod = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                cmethod[i] = <char>(buf[i])
-        if site is not None:
-            buf = site.encode('utf-8') + bytes([0])
-            csite = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                csite[i] = <char>(buf[i])
-        rmethod, rsite = None, None
-        if libcoopgamma_get_method_and_site(cmethod, csite, &rcsmethod, &rcssite) < 0:
-            return int(errno)
-        rbsmethod = rcsmethod
-        rmethod = rbsmethod.decode('utf-8', 'strict')
-        if rcssite is not NULL:
-            rbssite = rcssite
-            rsite = rbssite.decode('utf-8', 'strict')
-        return (rmethod, rsite)
-    finally:
-        free(cmethod)
-        free(csite)
-        free(rcsmethod)
-        free(rcssite)
-
-
-def libcoopgamma_native_get_pid_file(method : str, site : str):
-    '''
-    Get the PID file of the coopgamma server
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:str?  The adjustment method, `None` for automatic
-    @param   site:str?    The site, `None` for automatic
-    @return  :int|str?    Either the value of `errno` (on failure), or (on success)
-                          the pathname of the server's PID file. `None` if the server
-                          does not use PID files.
-    '''
-    cdef char* cmethod = NULL
-    cdef char* csite = NULL
-    cdef char* path = NULL
-    cdef bytes bs
-    try:
-        if method is not None:
-            buf = method.encode('utf-8') + bytes([0])
-            cmethod = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                cmethod[i] = <char>(buf[i])
-        if site is not None:
-            buf = site.encode('utf-8') + bytes([0])
-            csite = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                csite[i] = <char>(buf[i])
-        path = libcoopgamma_get_pid_file(cmethod, csite)
-        if path is not NULL or errno == 0:
-            bs = path
-            return bs.decode('utf-8', 'strict')
-    finally:
-        free(cmethod)
-        free(csite)
-        free(path)
-    return int(errno)
-
-
-def libcoopgamma_native_get_socket_file(method : str, site : str):
-    '''
-    Get the socket file of the coopgamma server
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:int|str?  The adjustment method, `None` for automatic
-    @param   site:str?        The site, `None` for automatic
-    @return  :int|str?        Either the value of `errno` (on failure), or (on success)
-                              the pathname of the server's socket, `None` if the server does have
-                              its own socket, which is the case when communicating with a server
-                              in a multi-server display server like mds
-    '''
-    cdef char* cmethod = NULL
-    cdef char* csite = NULL
-    cdef char* path = NULL
-    cdef bytes bs
-    try:
-        if method is not None:
-            buf = method.encode('utf-8') + bytes([0])
-            cmethod = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                cmethod[i] = <char>(buf[i])
-        if site is not None:
-            buf = site.encode('utf-8') + bytes([0])
-            csite = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                csite[i] = <char>(buf[i])
-        path = libcoopgamma_get_socket_file(cmethod, csite)
-        if path is not NULL or errno == 0:
-            bs = path
-            return bs.decode('utf-8', 'strict')
-    finally:
-        free(cmethod)
-        free(csite)
-        free(path)
-    return int(errno)
-
-
-def libcoopgamma_native_context_create():
-    '''
-    Create an instance of `libcoopgamma_context_t`
-    
-    @return  :(:bool, :int)  Element 0: Whether the call was successful
-                             Element 1: The value of `errno` on failure, and on
-                                        success, the address of the created instance
-    '''
-    cdef libcoopgamma_context_t* this
-    this = <libcoopgamma_context_t*>malloc(sizeof(libcoopgamma_context_t))
-    if this is NULL:
-        return (False, int(errno))
-    if libcoopgamma_context_initialise(this) < 0:
-        saved_errno = int(errno)
-        libcoopgamma_context_destroy(this, <int>0)
-        free(this)
-        return (False, saved_errno)
-    return (True, int(<intptr_t><void*>this))
-
-
-def libcoopgamma_native_context_free(address : int):
-    '''
-    Disconnect and free an instance of a `libcoopgamma_context_t`
-    
-    @param  address:int  The address of the `libcoopgamma_context_t` instance
-    '''
-    cdef libcoopgamma_context_t* this = <libcoopgamma_context_t*><void*><intptr_t>address
-    libcoopgamma_context_destroy(this, <int>1)
-    free(this)
-
-
-def libcoopgamma_native_context_marshal(address : int):
-    '''
-    Marshal a `libcoopgamma_context_t` into a buffer
-    
-    @param   address:int  The address of the instance to marshal
-    @return  :int|bytes   Either the value of `errno` (on failure), or (on success)
-                          a byte representation of the instance
-    '''
-    cdef libcoopgamma_context_t* this = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef size_t n = libcoopgamma_context_marshal(this, NULL)
-    cdef char* buf = <char*>malloc(n)
-    if buf is NULL:
-        return int(errno)
-    try:
-        libcoopgamma_context_marshal(this, buf)
-        return bytes(int(<int><unsigned char>(buf[i])) for i in range(int(n)))
-    finally:
-        free(buf)
-
-
-def libcoopgamma_native_context_unmarshal(buf : bytes):
-    '''
-    Unmarshal a `libcoopgamma_context_t` from a buffer
-    
-    @param   buf:bytes      The buffer with the marshalled instance
-    @return  :(:int, :int)  Element 0: 0 = Success
-                                       1 = Incompatible downgrade
-                                       2 = Incompatible upgrade
-                                       -1 = `errno` is returned
-                            Element 1: If [0] = 0:  The address of the unmarshalled instance
-                                       If [0] = -1: The value of `errno`
-    '''
-    cdef size_t _n = 0
-    cdef libcoopgamma_context_t* this
-    cdef char* bs = NULL
-    success = False
-    this = <libcoopgamma_context_t*>calloc(1, sizeof(libcoopgamma_context_t))
-    if this is NULL:
-        return (-1, int(errno))
-    try:
-        if libcoopgamma_context_initialise(this) < 0:
-            return (-1, int(errno))
-        bs = <char*>malloc(len(buf) * sizeof(char))
-        if bs is NULL:
-            return (-1, int(errno))
-        for i in range(len(buf)):
-            bs[i] = <char><unsigned char>(buf[i])
-        ret = int(libcoopgamma_context_unmarshal(this, bs, &_n))
-        ret = (ret, int(<intptr_t><void*>this))
-        success = True
-        return ret
-    finally:
-        if not success:
-            libcoopgamma_context_destroy(this, <int>1)
-            free(this)
-        free(bs)
-
-
-def libcoopgamma_native_context_set_fd(address : int, fd : int):
-    '''
-    Set the field for socket file descriptor in a `libcoopgamma_context_t` 
-    
-    @param  address:int  The address of the `libcoopgamma_context_t` instance
-    @param  fd:int       The file descriptor
-    '''
-    cdef libcoopgamma_context_t* this = <libcoopgamma_context_t*><void*><intptr_t>address
-    this.fd = fd
-
-
-def libcoopgamma_native_async_context_create():
-    '''
-    Create an instance of `libcoopgamma_context_t`
-    
-    @return  :(:bool, :int)  Element 0: Whether the call was successful
-                             Element 1: The value of `errno` on failure, and on
-                                        success, the address of the created instance
-    '''
-    cdef libcoopgamma_context_t* this
-    this = <libcoopgamma_context_t*>malloc(sizeof(libcoopgamma_context_t))
-    if this is NULL:
-        return (False, int(errno))
-    if libcoopgamma_context_initialise(this) < 0:
-        saved_errno = int(errno)
-        libcoopgamma_context_destroy(this, <int>0)
-        free(this)
-        return (False, saved_errno)
-    return (True, int(<intptr_t><void*>this))
-
-
-def libcoopgamma_native_async_context_free(address : int):
-    '''
-    Free an instance of a `libcoopgamma_async_context_t`
-    
-    @param  address:int  The address of the `libcoopgamma_async_context_t` instance
-    '''
-    cdef libcoopgamma_async_context_t* this = <libcoopgamma_async_context_t*><void*><intptr_t>address
-    libcoopgamma_async_context_destroy(this)
-    free(this)
-
-
-def libcoopgamma_native_async_context_marshal(address : int):
-    '''
-    Marshal a `libcoopgamma_async_context_t` into a buffer
-    
-    @param   address:int  The address of the instance to marshal
-    @return  :int|bytes   Either the value of `errno` (on failure), or (on success)
-                          a byte representation of the instance
-    '''
-    cdef libcoopgamma_async_context_t* this = <libcoopgamma_async_context_t*><void*><intptr_t>address
-    cdef size_t n = libcoopgamma_async_context_marshal(this, NULL)
-    cdef char* buf = <char*>malloc(n)
-    try:
-        if buf is NULL:
-            return int(errno)
-        libcoopgamma_async_context_marshal(this, buf)
-        ret = bytes(int(<int><unsigned char>(buf[i])) for i in range(int(n)))
-    finally:
-        free(buf)
-    return ret
-
-
-def libcoopgamma_native_async_context_unmarshal(buf : bytes):
-    '''
-    Unmarshal a `libcoopgamma_async_context_t` from a buffer
-    
-    @param   buf:bytes      The buffer with the marshalled instance
-    @return  :(:int, :int)  Element 0: 0 = Success
-                                       1 = Incompatible downgrade
-                                       2 = Incompatible upgrade
-                                       -1 = `errno` is returned
-                            Element 1: If [0] = 0:  The address of the unmarshalled instance
-                                       If [0] = -1: The value of `errno`
-    '''
-    cdef size_t _n = 0
-    cdef libcoopgamma_async_context_t* this
-    cdef char* bs = NULL
-    successful = False
-    this = <libcoopgamma_async_context_t*>malloc(sizeof(libcoopgamma_async_context_t))
-    try:
-        if this is NULL:
-            return (-1, int(errno))
-        if libcoopgamma_async_context_initialise(this) < 0:
-            return (-1, int(errno))
-        bs = <char*>malloc(len(buf) * sizeof(char))
-        if bs is NULL:
-            return (-1, int(errno))
-        for i in range(len(buf)):
-            bs[i] = <char><unsigned char>(buf[i])
-        ret = int(libcoopgamma_async_context_unmarshal(this, bs, &_n))
-        ret = (ret, int(<intptr_t><void*>this))
-        success = True
-        return ret
-    finally:
-        if not success:
-            libcoopgamma_async_context_destroy(this)
-            free(this)
-        free(bs)
-
-
-def libcoopgamma_native_connect(method : str, site : str, address : int):
-    '''
-    Connect to a coopgamma server, and start it if necessary
-    
-    Use `libcoopgamma_context_destroy` to disconnect
-    
-    SIGCHLD must not be ignored or blocked
-    
-    @param   method:str?     The adjustment method, `NULL` for automatic
-    @param   site:str?       The site, `NULL` for automatic
-    @param   address:int     The address of the state of the library, must be initialised
-    @return  :(:bool, :int)  If [0] = `True`: [1] is the socket's file descriptor.
-                             If [0] = `False`: [1] is 0 if the server on could not be
-                                 initialised, or the value `errno` on other errors
-    '''
-    cdef char* cmethod = NULL
-    cdef char* csite = NULL
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    try:
-        if method is not None:
-            buf = method.encode('utf-8') + bytes([0])
-            cmethod = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                cmethod[i] = <char>(buf[i])
-        if site is not None:
-            buf = site.encode('utf-8') + bytes([0])
-            csite = <char*>malloc(len(buf) * sizeof(char))
-            for i in range(len(buf)):
-                csite[i] = <char>(buf[i])
-        if libcoopgamma_connect(cmethod, csite, ctx) < 0:
-            return (False, int(errno))
-        return (True, int(ctx.fd))
-    finally:
-        free(cmethod)
-        free(csite)
-
-
-def libcoopgamma_native_set_nonblocking(address : int, nonblocking : bool):
-    '''
-    By default communication is blocking, this function
-    can be used to switch between blocking and nonblocking
-    
-    After setting the communication to nonblocking,
-    `libcoopgamma_flush`, `libcoopgamma_synchronise` and
-    and request-sending functions can fail with EAGAIN and
-    EWOULDBLOCK. It is safe to continue with `libcoopgamma_flush`
-    (for `libcoopgamma_flush` it selfand equest-sending functions)
-    or `libcoopgamma_synchronise` just like EINTR failure.
-    
-    @param   address:int       The address of the state of the library, must be connected
-    @param   nonblocking:bool  Nonblocking mode?
-    @return  :int              Zero on success, the value of `errno` on error
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    if libcoopgamma_set_nonblocking(ctx, <int>(1 if nonblocking else 0)) < 0:
-        return int(errno)
-    return 0
-
-
-def libcoopgamma_native_flush(address : int):
-    '''
-    Send all pending outbound data
-    
-    If this function or another function that sends a request
-    to the server fails with EINTR, call this function to
-    complete the transfer. The `async_ctx` parameter will always
-    be in a properly configured state if a function fails
-    with EINTR.
-    
-    @param   address:int  The address of the state of the library, must be connected
-    @return  :int         Zero on success, the value of `errno` on error
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    if libcoopgamma_flush(ctx) < 0:
-        return int(errno)
-    return 0
-
-
-def libcoopgamma_native_synchronise(address : int, pending : list):
-    '''
-    Wait for the next message to be received
-    
-    @param   address:int        The address of the state of the library, must be connected
-    @param   pending:list<int>  Addresses of the information for each pending request
-    @return  :(:bool, :int)     If [0] = 0: [1] is the value of `errno`
-                                   [0] = 1: [1] is the selected request
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* pends
-    cdef libcoopgamma_async_context_t* pend
-    cdef size_t selected = 0
-    pends = <libcoopgamma_async_context_t*>malloc(len(pending) * sizeof(libcoopgamma_async_context_t))
-    try:
-        if pends is NULL:
-            return (False, int(errno))
-        for i in range(len(pending)):
-            pend = <libcoopgamma_async_context_t*><void*><intptr_t>(pending[i])
-            pends[i] = pend[0]
-        if libcoopgamma_synchronise(ctx, pends, <size_t>len(pending), &selected) < 0:
-            return (False, int(errno))
-    finally:
-        free(pends)
-    return (True, <int>selected)
-
-
-def libcoopgamma_native_skip_message(address : int):
-    '''
-    Tell the library that you will not be parsing a receive message
-    
-    @param  address:int  The address of the state of the library, must be connected
-    '''
-    libcoopgamma_skip_message(<libcoopgamma_context_t*><void*><intptr_t>address)
-
-
-def libcoopgamma_native_get_crtcs_send(address : int, async_ctx : int):
-    '''
-    List all available CRTC:s, send request part
-    
-    @param   address:int    The address of the state of the library, must be connected
-    @param   async_ctx:int  The address of the `AsyncContext` for the request
-    @return  :int           Zero on success, the value of `errno` on failure
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    if libcoopgamma_get_crtcs_send(ctx, actx) < 0:
-        return int(errno)
-    return 0
-
-
-def libcoopgamma_native_get_crtcs_recv(address : int, async_ctx : int):
-    '''
-    List all available CRTC:s, receive response part
-    
-    @param   address:int     The address of the state of the library, must be connected
-    @param   async_ctx:int   The address of the `AsyncContext` for the request
-    @return  :int|list<str>  The value of `errno` (on failure), or (on success)
-                             a list of the names of the available CRTC:s
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef char** crtcs = libcoopgamma_get_crtcs_recv(ctx, actx)
-    cdef bytes bs
-    if crtcs is NULL:
-        return int(errno)
-    try:
-        ret, i = [], 0
-        while crtcs[i] is not NULL:
-            bs = crtcs[i]
-            ret.append(bs.decode('utf-8', 'strict'))
-            i += 1
-    finally:
-        free(crtcs)
-    return ret
-
-
-def libcoopgamma_native_get_crtcs_sync(address : int):
-    '''
-    List all available CRTC:s, synchronous version
-    
-    This is a synchronous request function, as such,
-    you have to ensure that communication is blocking
-    (default), and that there are not asynchronous
-    requests waiting, it also means that EINTR:s are
-    silently ignored and there no wait to cancel the
-    operation without disconnection from the server
-    
-    @param   address:int     The address of the state of the library, must be connected
-    @return  :int|list<str>  The value of `errno` (on failure), or (on success)
-                             a list of the names of the available CRTC:s
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef char** crtcs = libcoopgamma_get_crtcs_sync(ctx)
-    cdef bytes bs
-    try:
-        if crtcs is NULL:
-            return int(errno)
-        ret, i = [], 0
-        while crtcs[i] is not NULL:
-            bs = crtcs[i]
-            ret.append(bs.decode('utf-8', 'strict'))
-            i += 1
-    finally:
-        free(crtcs)
-    return ret
-
-
-def libcoopgamma_native_get_gamma_info_send(crtc : str, address : int, async_ctx : int):
-    '''
-    Retrieve information about a CRTC:s gamma ramps, send request part
-    
-    Cannot be used before connecting to the server
-    
-    @param   crtc:crtc      The name of the CRTC
-    @param   address:int    The address of the state of the library, must be connected
-    @param   async_ctx:int  The address of the information about the request, that is
-                            needed to identify and parse the response, is stored here
-    @return  :int           Zero on success, the value of `errno` on error
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef char* ccrtc = NULL
-    try:
-        bs = crtc.encode('utf-8') + bytes([0])
-        ccrtc = <char*>malloc(len(bs) * sizeof(char))
-        if ccrtc is NULL:
-            return int(errno)
-        for i in range(len(bs)):
-            ccrtc[i] = <char>(bs[i])
-        if libcoopgamma_get_gamma_info_send(ccrtc, ctx, actx) < 0:
-            return int(errno)
-    finally:
-        free(ccrtc)
-    return 0
-
-
-def libcoopgamma_native_get_gamma_info_recv(address : int, async_ctx : int):
-    '''
-    Retrieve information about a CRTC:s gamma ramps, receive response part
-    
-    @param   address:int           The address of the state of the library, must be connected 
-    @param   async_ctx:int         The address of the information about the request
-    @return  :int|(:bool, :tuple)  The value of `errno` (on failure) or:
-                                   Element 0: whether the call was successful
-                                   Element 1: tuple with the data for the structure response (possibly error)
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef libcoopgamma_crtc_info_t info
-    cdef bytes bs
-    try:
-        if libcoopgamma_crtc_info_initialise(&info) < 0:
-            return int(errno)
-        if libcoopgamma_get_gamma_info_recv(&info, ctx, actx) < 0:
-            desc = None
-            if ctx.error.description is not NULL:
-                bs = ctx.error.description
-                desc = bs.decode('utf-8', 'strict')
-            ret = (False, (int(ctx.error.number), ctx.error.custom != 0, ctx.error.server_side != 0, desc))
-        else:
-            ret = (True, (info.cooperative != 0, int(info.depth), int(info.supported), int(info.red_size),
-                          int(info.green_size), int(info.blue_size), int(info.colourspace),
-                          None if info.have_gamut == 0 else ((info.red_x, info.red_y),
-                                                             (info.green_x, info.green_y),
-                                                             (info.blue_x, info.blue_y),
-                                                             (info.white_x, info.white_y))))
-    finally:
-        libcoopgamma_crtc_info_destroy(&info)
-    return ret
-
-
-def libcoopgamma_native_get_gamma_info_sync(crtc : str, address : int):
-    '''
-    Retrieve information about a CRTC:s gamma ramps, synchronous version
-    
-    This is a synchronous request function, as such, you have to ensure that
-    communication is blocking (default), and that there are not asynchronous
-    requests waiting, it also means that EINTR:s are silently ignored and
-    there no wait to cancel the operation without disconnection from the server
-    
-    @param   crtc:str              The name of the CRTC
-    @param   address:int           The address of the state of the library, must be connected
-    @return  :int|(:bool, :tuple)  The value of `errno` (on failure) or:
-                                   Element 0: whether the call was successful
-                                   Element 1: tuple with the data for the structure response (possibly error)
-    '''
-    cdef char* ccrtc = NULL
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_crtc_info_t info
-    cdef bytes bs
-    try:
-        if libcoopgamma_crtc_info_initialise(&info) < 0:
-            return int(errno)
-        bscrtc = crtc.encode('utf-8') + bytes([0])
-        ccrtc = <char*>malloc(len(bscrtc) * sizeof(bscrtc))
-        for i in range(len(bscrtc)):
-            ccrtc[i] = <char>(bscrtc[i])
-        if libcoopgamma_get_gamma_info_sync(ccrtc, &info, ctx) < 0:
-            desc = None
-            if ctx.error.description is not NULL:
-                bs = ctx.error.description
-                desc = bs.decode('utf-8', 'strict')
-            ret = (False, (int(ctx.error.number), ctx.error.custom != 0, ctx.error.server_side != 0, desc))
-        else:
-            ret = (True, (info.cooperative != 0, int(info.depth), int(info.supported), int(info.red_size),
-                          int(info.green_size), int(info.blue_size), int(info.colourspace),
-                          None if info.have_gamut == 0 else ((info.red_x, info.red_y),
-                                                             (info.green_x, info.green_y),
-                                                             (info.blue_x, info.blue_y),
-                                                             (info.white_x, info.white_y))))
-    finally:
-        libcoopgamma_crtc_info_destroy(&info)
-        free(ccrtc)
-    return ret
-
-
-def libcoopgamma_native_get_gamma_send(query, address : int, async_ctx : int):
-    
-    '''
-    Retrieve the current gamma ramp adjustments, send request part
-    
-    Cannot be used before connecting to the server
-    
-    @param   query:Query    The query to send
-    @param   address:int    The address of the state of the library, must be connected
-    @param   async_ctx:int  The address of the information about the request, that is
-                            needed to identify and parse the response, is stored here
-    @return                 Zero on success, the value of `errno` on failure
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef libcoopgamma_filter_query_t qry
-    crtc_bs = query.crtc.encode('utf-8') + bytes([0])
-    qry.high_priority = <int64_t>(query.high_priority)
-    qry.low_priority = <int64_t>(query.low_priority)
-    qry.coalesce = <int>(query.coalesce)
-    qry.crtc = <char*>malloc(len(crtc_bs) * sizeof(char))
-    try:
-        if qry.crtc is NULL:
-            return int(errno)
-        for i in range(len(crtc_bs)):
-            qry.crtc[i] = <char>(crtc_bs[i])
-        if libcoopgamma_get_gamma_send(&qry, ctx, actx) < 0:
-            return int(errno)
-    finally:
-        free(qry.crtc)
-    return 0
-    
-
-def libcoopgamma_native_get_gamma_recv(address : int, async_ctx : int):
-    '''
-    Retrieve the current gamma ramp adjustments, receive response part
-    
-    @param   address:int           The address of the state of the library, must be connected
-    @param   async_ctx:int         The address of the information about the request
-    @return  :int|(:bool, :tuple)  The value of `errno` (on failure) or:
-                                   Element 0: whether the call was successful
-                                   Element 1: tuple with the data for the structure response (possibly error)
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef libcoopgamma_filter_table_t table
-    cdef bytes bs
-    cdef libcoopgamma_ramps_t* rampsp
-    cdef char* fclass
-    try:
-        if libcoopgamma_filter_table_initialise(&table) < 0:
-            return int(errno)
-        if libcoopgamma_get_gamma_recv(&table, ctx, actx) < 0:
-            desc = None
-            if ctx.error.description is not NULL:
-                bs = ctx.error.description
-                desc = bs.decode('utf-8', 'strict')
-            ret = (False, (int(ctx.error.number), ctx.error.custom != 0, ctx.error.server_side != 0, desc))
-        else:
-            filters = [None] * int(table.filter_count)
-            for j in range(int(table.filter_count)):
-                rampsp = &(table.filters[j].ramps)
-                fclass = table.filters[j].fclass
-                red   = [None] * rampsp.u_red_size
-                green = [None] * rampsp.u_green_size
-                blue  = [None] * rampsp.u_blue_size
-                if table.depth == -2:
-                    for i in range(rampsp.u_red_size):
-                        red[i] = (<double*>(rampsp.u_red))[i]
-                    for i in range(rampsp.u_green_size):
-                        green[i] = (<double*>(rampsp.u_green))[i]
-                    for i in range(rampsp.u_blue_size):
-                        blue[i] = (<double*>(rampsp.u_blue))[i]
-                elif table.depth == -1:
-                    for i in range(rampsp.u_red_size):
-                        red[i] = (<float*>(rampsp.u_red))[i]
-                    for i in range(rampsp.u_green_size):
-                        green[i] = (<float*>(rampsp.u_green))[i]
-                    for i in range(rampsp.u_blue_size):
-                        blue[i] = (<float*>(rampsp.u_blue))[i]
-                elif table.depth == 8:
-                    for i in range(rampsp.u_red_size):
-                        red[i] = (<uint8_t*>(rampsp.u_red))[i]
-                    for i in range(rampsp.u_green_size):
-                        green[i] = (<uint8_t*>(rampsp.u_green))[i]
-                    for i in range(rampsp.u_blue_size):
-                        blue[i] = (<uint8_t*>(rampsp.u_blue))[i]
-                elif table.depth == 16:
-                    for i in range(rampsp.u_red_size):
-                        red[i] = (<uint16_t*>(rampsp.u_red))[i]
-                    for i in range(rampsp.u_green_size):
-                        green[i] = (<uint16_t*>(rampsp.u_green))[i]
-                    for i in range(rampsp.u_blue_size):
-                        blue[i] = (<uint16_t*>(rampsp.u_blue))[i]
-                elif table.depth == 32:
-                    for i in range(rampsp.u_red_size):
-                        red[i] = (<uint32_t*>(rampsp.u_red))[i]
-                    for i in range(rampsp.u_green_size):
-                        green[i] = (<uint32_t*>(rampsp.u_green))[i]
-                    for i in range(rampsp.u_blue_size):
-                        blue[i] = (<uint32_t*>(rampsp.u_blue))[i]
-                elif table.depth == 64:
-                    for i in range(rampsp.u_red_size):
-                        red[i] = (<uint64_t*>(rampsp.u_red))[i]
-                    for i in range(rampsp.u_green_size):
-                        green[i] = (<uint64_t*>(rampsp.u_green))[i]
-                    for i in range(rampsp.u_blue_size):
-                        blue[i] = (<uint64_t*>(rampsp.u_blue))[i]
-                ramps = (red, green, blue)
-                pclass = None
-                if fclass is not NULL:
-                    bs = fclass
-                    pclass = bs.decode('utf-8', 'strict')
-                filters[j] = (int(table.filters[j].priority), pclass, ramps)
-            ret = (True, (int(table.red_size), int(table.green_size), int(table.blue_size),
-                          int(table.depth), filters))
-    finally:
-        libcoopgamma_filter_table_destroy(&table)
-    return ret
-
-
-def libcoopgamma_native_get_gamma_sync(query, address : int):
-    '''
-    Retrieve the current gamma ramp adjustments, synchronous version
-    
-    This is a synchronous request function, as such, you have to ensure that
-    communication is blocking (default), and that there are not asynchronous
-    requests waiting, it also means that EINTR:s are silently ignored and
-    there no wait to cancel the operation without disconnection from the server
-    
-    @param   query:Query           The query to send
-    @param   address:int           The address of the state of the library, must be connected
-    @return  :int|(:bool, :tuple)  The value of `errno` (on failure) or:
-                                   Element 0: whether the call was successful
-                                   Element 1: tuple with the data for the structure response (possibly error)
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_filter_table_t table
-    cdef libcoopgamma_filter_query_t qry
-    cdef bytes bs
-    cdef libcoopgamma_ramps_t* rampsp
-    cdef char* fclass
-    crtc_bs = query.crtc.encode('utf-8') + bytes([0])
-    qry.high_priority = <int64_t>(query.high_priority)
-    qry.low_priority = <int64_t>(query.low_priority)
-    qry.coalesce = <int>(query.coalesce)
-    qry.crtc = <char*>malloc(len(crtc_bs) * sizeof(char))
-    try:
-        if qry.crtc is NULL:
-            return int(errno)
-        for i in range(len(crtc_bs)):
-            qry.crtc[i] = <char>(crtc_bs[i])
-        if libcoopgamma_filter_table_initialise(&table) < 0:
-            saved_errno = int(errno)
-            libcoopgamma_filter_table_destroy(&table)
-            return saved_errno
-        try:
-            if libcoopgamma_get_gamma_sync(&qry, &table, ctx) < 0:
-                desc = None
-                if ctx.error.description is not NULL:
-                    bs = ctx.error.description
-                    desc = bs.decode('utf-8', 'strict')
-                ret = (False, (int(ctx.error.number), ctx.error.custom != 0, ctx.error.server_side != 0, desc))
-            else:
-                filters = [None] * int(table.filter_count)
-                for j in range(int(table.filter_count)):
-                    rampsp = &(table.filters[j].ramps)
-                    fclass = table.filters[j].fclass
-                    red   = [None] * rampsp.u_red_size
-                    green = [None] * rampsp.u_green_size
-                    blue  = [None] * rampsp.u_blue_size
-                    if table.depth == -2:
-                        for i in range(rampsp.u_red_size):
-                            red[i] = (<double*>(rampsp.u_red))[i]
-                        for i in range(rampsp.u_green_size):
-                            green[i] = (<double*>(rampsp.u_green))[i]
-                        for i in range(rampsp.u_blue_size):
-                            blue[i] = (<double*>(rampsp.u_blue))[i]
-                    elif table.depth == -1:
-                        for i in range(rampsp.u_red_size):
-                            red[i] = (<float*>(rampsp.u_red))[i]
-                        for i in range(rampsp.u_green_size):
-                            green[i] = (<float*>(rampsp.u_green))[i]
-                        for i in range(rampsp.u_blue_size):
-                            blue[i] = (<float*>(rampsp.u_blue))[i]
-                    elif table.depth == 8:
-                        for i in range(rampsp.u_red_size):
-                            red[i] = (<uint8_t*>(rampsp.u_red))[i]
-                        for i in range(rampsp.u_green_size):
-                            green[i] = (<uint8_t*>(rampsp.u_green))[i]
-                        for i in range(rampsp.u_blue_size):
-                            blue[i] = (<uint8_t*>(rampsp.u_blue))[i]
-                    elif table.depth == 16:
-                        for i in range(rampsp.u_red_size):
-                            red[i] = (<uint16_t*>(rampsp.u_red))[i]
-                        for i in range(rampsp.u_green_size):
-                            green[i] = (<uint16_t*>(rampsp.u_green))[i]
-                        for i in range(rampsp.u_blue_size):
-                            blue[i] = (<uint16_t*>(rampsp.u_blue))[i]
-                    elif table.depth == 32:
-                        for i in range(rampsp.u_red_size):
-                            red[i] = (<uint32_t*>(rampsp.u_red))[i]
-                        for i in range(rampsp.u_green_size):
-                            green[i] = (<uint32_t*>(rampsp.u_green))[i]
-                        for i in range(rampsp.u_blue_size):
-                            blue[i] = (<uint32_t*>(rampsp.u_blue))[i]
-                    elif table.depth == 64:
-                        for i in range(rampsp.u_red_size):
-                            red[i] = (<uint64_t*>(rampsp.u_red))[i]
-                        for i in range(rampsp.u_green_size):
-                            green[i] = (<uint64_t*>(rampsp.u_green))[i]
-                        for i in range(rampsp.u_blue_size):
-                            blue[i] = (<uint64_t*>(rampsp.u_blue))[i]
-                    ramps = (red, green, blue)
-                    pclass = None
-                    if fclass is not NULL:
-                        bs = fclass
-                        pclass = bs.decode('utf-8', 'strict')
-                    filters[j] = (int(table.filters[j].priority), pclass, ramps)
-                ret = (True, (int(table.red_size), int(table.green_size), int(table.blue_size),
-                              int(table.depth), filters))
-        finally:
-            libcoopgamma_filter_table_destroy(&table)
-    finally:
-        free(qry.crtc)
-    return ret
-
-
-def libcoopgamma_native_copy_ramps(intptr_t dest_address, src, libcoopgamma_depth_t depth):
-    '''
-    Copy a Python ramp-trio into C ramp-trio
-    
-    @param  dest_address:intptr_t       The address of the C ramp-trio
-    @param  src:Ramps                   The Python ramp-trio
-    @param  depth:libcoopgamma_depth_t  The data type of the ramp stops
-    '''
-    cdef libcoopgamma_ramps_t* dest = <libcoopgamma_ramps_t*><void*><intptr_t>dest_address
-    cdef uint8_t* r8
-    cdef uint8_t* g8
-    cdef uint8_t* b8
-    cdef uint16_t* r16
-    cdef uint16_t* g16
-    cdef uint16_t* b16
-    cdef uint32_t* r32
-    cdef uint32_t* g32
-    cdef uint32_t* b32
-    cdef uint64_t* r64
-    cdef uint64_t* g64
-    cdef uint64_t* b64
-    cdef float* rf
-    cdef float* gf
-    cdef float* bf
-    cdef double* rd
-    cdef double* gd
-    cdef double* bd
-    cdef size_t rn = <size_t>len(src.red)
-    cdef size_t gn = <size_t>len(src.green)
-    cdef size_t bn = <size_t>len(src.blue)
-    if depth == 8:
-        r8 = <uint8_t*>malloc((rn + gn + bn) * sizeof(uint8_t))
-        g8 = r8 + rn
-        b8 = g8 + gn
-        for i in range(int(rn)):
-            r8[i] = <uint8_t>(src.red[i])
-        for i in range(int(gn)):
-            g8[i] = <uint8_t>(src.green[i])
-        for i in range(int(bn)):
-            b8[i] = <uint8_t>(src.blue[i])
-        dest.u_red   = <void*>r8
-        dest.u_green = <void*>g8
-        dest.u_blue  = <void*>b8
-    elif depth == 16:
-        r16 = <uint16_t*>malloc((rn + gn + bn) * sizeof(uint16_t))
-        g16 = r16 + rn
-        b16 = g16 + gn
-        for i in range(int(rn)):
-            r16[i] = <uint16_t>(src.red[i])
-        for i in range(int(gn)):
-            g16[i] = <uint16_t>(src.green[i])
-        for i in range(int(bn)):
-            b16[i] = <uint16_t>(src.blue[i])
-        dest.u_red   = <void*>r16
-        dest.u_green = <void*>g16
-        dest.u_blue  = <void*>b16
-    elif depth == 32:
-        r32 = <uint32_t*>malloc((rn + gn + bn) * sizeof(uint32_t))
-        g32 = r32 + rn
-        b32 = g32 + gn
-        for i in range(int(rn)):
-            r32[i] = <uint32_t>(src.red[i])
-        for i in range(int(gn)):
-            g32[i] = <uint32_t>(src.green[i])
-        for i in range(int(bn)):
-            b32[i] = <uint32_t>(src.blue[i])
-        dest.u_red   = <void*>r32
-        dest.u_green = <void*>g32
-        dest.u_blue  = <void*>b32
-    elif depth == 64:
-        r64 = <uint64_t*>malloc((rn + gn + bn) * sizeof(uint64_t))
-        g64 = r64 + rn
-        b64 = g64 + gn
-        for i in range(int(rn)):
-            r64[i] = <uint64_t>(src.red[i])
-        for i in range(int(gn)):
-            g64[i] = <uint64_t>(src.green[i])
-        for i in range(int(bn)):
-            b64[i] = <uint64_t>(src.blue[i])
-        dest.u_red   = <void*>r64
-        dest.u_green = <void*>g64
-        dest.u_blue  = <void*>b64
-    elif depth == -1:
-        rf = <float*>malloc((rn + gn + bn) * sizeof(float))
-        gf = rf + rn
-        bf = gf + gn
-        for i in range(int(rn)):
-            rf[i] = <float>(src.red[i])
-        for i in range(int(gn)):
-            gf[i] = <float>(src.green[i])
-        for i in range(int(bn)):
-            bf[i] = <float>(src.blue[i])
-        dest.u_red   = <void*>rf
-        dest.u_green = <void*>gf
-        dest.u_blue  = <void*>bf
-    else:
-        rd = <double*>malloc((rn + gn + bn) * sizeof(double))
-        gd = rd + rn
-        bd = gd + gn
-        for i in range(int(rn)):
-            rd[i] = <double>(src.red[i])
-        for i in range(int(gn)):
-            gd[i] = <double>(src.green[i])
-        for i in range(int(bn)):
-            bd[i] = <double>(src.blue[i])
-        dest.u_red   = <void*>rd
-        dest.u_green = <void*>gd
-        dest.u_blue  = <void*>bd
-
-
-def libcoopgamma_native_set_gamma_send(filtr, address : int, async_ctx : int):
-    '''
-    Apply, update, or remove a gamma ramp adjustment, send request part
-    
-    Cannot be used before connecting to the server
-    
-    @param   filtr:Filter   The filter to apply, update, or remove, gamma ramp
-                            meta-data must match the CRTC's
-    @param   address:int    The address of the state of the library, must be connected
-    @param   async_ctx:int  The address of the information about the request, that is needed to
-                            identify and parse the response, is stored here
-    @return  :int           Zero on success, the value of `errno` on failure
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef libcoopgamma_filter_t flr
-    crtc_bs = filtr.crtc.encode('utf-8') + bytes([0])
-    clss_bs = filtr.fclass.encode('utf-8') + bytes([0])
-    flr.priority = <int64_t>(0 if filtr.priority is None else filtr.priority)
-    flr.lifespan = <libcoopgamma_lifespan_t>(filtr.lifespan)
-    flr.depth = <libcoopgamma_depth_t>(0 if filtr.depth is None else filtr.depth)
-    flr.fclass = NULL
-    flr.crtc = NULL
-    flr.ramps.u_red_size   = len(filtr.ramps.red)   if filtr.ramps is not None else 0
-    flr.ramps.u_green_size = len(filtr.ramps.green) if filtr.ramps is not None else 0
-    flr.ramps.u_blue_size  = len(filtr.ramps.blue)  if filtr.ramps is not None else 0
-    flr.ramps.u_red   = NULL
-    flr.ramps.u_green = NULL
-    flr.ramps.u_blue  = NULL
-    try:
-        if filtr.ramps is not None:
-            libcoopgamma_native_copy_ramps(<intptr_t><void*>&(flr.ramps), filtr.ramps, flr.depth)
-        flr.crtc = <char*>malloc(len(crtc_bs) * sizeof(char))
-        if flr.crtc is NULL:
-            return int(errno)
-        flr.fclass = <char*>malloc(len(clss_bs) * sizeof(char))
-        if flr.fclass is NULL:
-            return int(errno)
-        for i in range(len(crtc_bs)):
-            flr.crtc[i] = <char>(crtc_bs[i])
-        for i in range(len(clss_bs)):
-            flr.fclass[i] = <char>(clss_bs[i])
-        if libcoopgamma_set_gamma_send(&flr, ctx, actx) < 0:
-            return int(errno)
-    finally:
-        free(flr.crtc)
-        free(flr.fclass)
-        free(flr.ramps.u_red)
-    return 0
-
-
-def libcoopgamma_native_set_gamma_recv(address : int, async_ctx : int):
-    '''
-    Apply, update, or remove a gamma ramp adjustment, receive response part
-    
-    @param   address:int    The address of the state of the library, must be connected
-    @param   async_ctx:int  The address of the information about the request
-    @return  :tuple?        The value of `errno` (on failure) or:
-                            Element 0: whether the call was successful
-                            Element 1: tuple with the data for the structure response (possibly error)
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_async_context_t* actx = <libcoopgamma_async_context_t*><void*><intptr_t>async_ctx
-    cdef bytes bs
-    if libcoopgamma_set_gamma_recv(ctx, actx) < 0:
-        desc = None
-        if ctx.error.description is not NULL:
-            bs = ctx.error.description
-            desc = bs.decode('utf-8', 'strict')
-        return (int(ctx.error.number), ctx.error.custom != 0, ctx.error.server_side != 0, desc)
-    return None
-
-
-def libcoopgamma_native_set_gamma_sync(filtr, address : int):
-    '''
-    Apply, update, or remove a gamma ramp adjustment, synchronous version
-    
-    This is a synchronous request function, as such, you have to ensure that
-    communication is blocking (default), and that there are not asynchronous
-    requests waiting, it also means that EINTR:s are silently ignored and
-    there no wait to cancel the operation without disconnection from the server
-    
-    @param   filtr:Filter  The filter to apply, update, or remove, gamma ramp
-                           meta-data must match the CRTC's
-    @param   address:int   The address of the state of the library, must be connected
-    @return  :tuple?       The value of `errno` (on failure) or:
-                           Element 0: whether the call was successful
-                           Element 1: tuple with the data for the structure response (possibly error)
-    '''
-    cdef libcoopgamma_context_t* ctx = <libcoopgamma_context_t*><void*><intptr_t>address
-    cdef libcoopgamma_filter_t flr
-    cdef bytes bs
-    crtc_bs = filtr.crtc.encode('utf-8') + bytes([0])
-    clss_bs = filtr.fclass.encode('utf-8') + bytes([0])
-    flr.priority = <int64_t>(0 if filtr.priority is None else filtr.priority)
-    flr.lifespan = <libcoopgamma_lifespan_t>(filtr.lifespan)
-    flr.depth = <libcoopgamma_depth_t>(0 if filtr.depth is None else filtr.depth)
-    flr.fclass = NULL
-    flr.crtc = NULL
-    flr.ramps.u_red_size   = len(filtr.ramps.red)   if filtr.ramps is not None else 0
-    flr.ramps.u_green_size = len(filtr.ramps.green) if filtr.ramps is not None else 0
-    flr.ramps.u_blue_size  = len(filtr.ramps.blue)  if filtr.ramps is not None else 0
-    flr.ramps.u_red   = NULL
-    flr.ramps.u_green = NULL
-    flr.ramps.u_blue  = NULL
-    try:
-        if filtr.ramps is not None:
-            libcoopgamma_native_copy_ramps(<intptr_t><void*>&(flr.ramps), filtr.ramps, flr.depth)
-        flr.crtc = <char*>malloc(len(crtc_bs) * sizeof(char))
-        if flr.crtc is NULL:
-            return int(errno)
-        flr.fclass = <char*>malloc(len(clss_bs) * sizeof(char))
-        if flr.fclass is NULL:
-            return int(errno)
-        for i in range(len(crtc_bs)):
-            flr.crtc[i] = <char>(crtc_bs[i])
-        for i in range(len(clss_bs)):
-            flr.fclass[i] = <char>(clss_bs[i])
-        if libcoopgamma_set_gamma_sync(&flr, ctx) < 0:
-            desc = None
-            if ctx.error.description is not NULL:
-                bs = ctx.error.description
-                desc = bs.decode('utf-8', 'strict')
-            return (int(ctx.error.number), ctx.error.custom != 0, ctx.error.server_side != 0, desc)
-    finally:
-        free(flr.crtc)
-        free(flr.fclass)
-        free(flr.ramps.u_red)
-    return None
-
diff --git a/src/test b/src/test
deleted file mode 100755
index f2bb71e..0000000
--- a/src/test
+++ /dev/null
@@ -1,376 +0,0 @@
-#!/usr/bin/env python3
-'''
-pylibcoopgamma -- Python library for interfacing with cooperative gamma servers
-Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
-
-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/>.
-'''
-
-import os, sys, time, errno, select
-
-os.chdir('/'.join(sys.argv[0].split('/')[:-1]))
-sys.path.append('../bin')
-
-import libcoopgamma
-cg = libcoopgamma
-
-if len(sys.argv) == 1:
-    
-    print('\033[1m%s:\033[m' % 'Methods')
-    for m in cg.get_methods():
-        print(m)
-    print()
-    
-    print('\033[1m%s:\033[m' % 'Method')
-    print(cg.get_method_and_site()[0])
-    print()
-    
-    print('\033[1m%s:\033[m' % 'Site')
-    print(cg.get_method_and_site()[1])
-    print()
-    
-    print('\033[1m%s:\033[m' % 'PID file')
-    print(cg.get_pid_file())
-    print()
-    
-    print('\033[1m%s:\033[m' % 'Socket')
-    print(cg.get_socket_file())
-    print()
-    
-    g = cg.Context()
-    g.connect()
-    g.detach()
-    gstr = repr(g)
-    del g
-    
-    argv0 = './' + sys.argv[0].split('/')[-1]
-    os.execl(argv0, argv0, gstr)
-else:
-    g = eval(sys.argv[1])
-    g.attach()
-    pass
-
-print('\033[1m%s:\033[m' % 'CRTC:s')
-crtcs = g.get_crtcs_sync()
-for crtc in crtcs:
-    print(crtc)
-print()
-
-info = g.get_gamma_info_sync(crtc)
-print('\033[1m%s:\033[m' % 'CRTC info')
-print('Cooperative:', 'yes' if info.cooperative else 'no')
-if info.depth is not None:
-    print('Depth:', cg.Depth.str(info.depth))
-print('Supported:', cg.Support.str(info.supported))
-if info.red_size is not None:
-    print('Red stops:', info.red_size)
-if info.green_size is not None:
-    print('Green stops:', info.green_size)
-if info.blue_size is not None:
-    print('Blue stops:', info.blue_size)
-print('Colourspace:', cg.Colourspace.str(info.colourspace))
-if info.gamut is not None:
-    print('Red point:', str(info.gamut.red))
-    print('Green point:', str(info.gamut.green))
-    print('Blue point:', str(info.gamut.blue))
-    print('White point:', str(info.gamut.white))
-print()
-
-table = g.get_gamma_sync(cg.FilterQuery(crtc = crtc, coalesce = False))
-print('\033[1m%s:\033[m' % 'Filter table')
-print('Red stops:', table.red_size)
-print('Green stops:', table.green_size)
-print('Blue stops:', table.blue_size)
-print('Depth:', cg.Depth.str(table.depth))
-for i, fltr in enumerate(table.filters):
-    print('Filter %i:' % i)
-    print('  Priority:', fltr.priority)
-    print('  Class:', fltr.fclass)
-    print('  Ramps:')
-    rr, gr, br = fltr.ramps.red, fltr.ramps.green, fltr.ramps.blue
-    n = max(len(rr), len(gr), len(br))
-    fmt = '    \033[31m%s \033[32m%s \033[34m%s\033[m'
-    rr = [str(rr[i]) if i < len(rr) else '' for i in range(n)]
-    gr = [str(gr[i]) if i < len(gr) else '' for i in range(n)]
-    br = [str(br[i]) if i < len(br) else '' for i in range(n)]
-    for y in zip(rr, gr, br):
-        print(fmt % y)
-print()
-table_nc = table
-
-table = g.get_gamma_sync(cg.FilterQuery(crtc = crtc, coalesce = True))
-print('\033[1m%s:\033[m' % 'Filter table')
-print('Red stops:', table.red_size)
-print('Green stops:', table.green_size)
-print('Blue stops:', table.blue_size)
-print('Depth:', cg.Depth.str(table.depth))
-for fltr in table.filters:
-    print('Ramps:')
-    rr, gr, br = fltr.ramps.red, fltr.ramps.green, fltr.ramps.blue
-    n = max(len(rr), len(gr), len(br))
-    fmt = '  \033[31m%s \033[32m%s \033[34m%s\033[m'
-    rr = [str(rr[i]) if i < len(rr) else '' for i in range(n)]
-    gr = [str(gr[i]) if i < len(gr) else '' for i in range(n)]
-    br = [str(br[i]) if i < len(br) else '' for i in range(n)]
-    for y in zip(rr, gr, br):
-        print(fmt % y)
-print()
-table_c = table
-
-fltr = cg.Filter(0, crtc, 'pylibcoopgamma::test::test', cg.Lifespan.UNTIL_DEATH, table.depth,
-                 cg.Ramps(table.red_size, table.green_size, table.blue_size))
-
-if table.depth < 0:
-    Y = lambda x : x
-else:
-    m = 2 ** table.depth - 1
-    Y = lambda x : int(x * m)
-
-redzero = fltr.ramps.red
-greenzero = fltr.ramps.green
-redid = [Y(x / (table.red_size - 1)) for x in range(table.red_size)]
-greenid = [Y(x / (table.green_size - 1)) for x in range(table.green_size)]
-blueid = [Y(x / (table.blue_size - 1)) for x in range(table.blue_size)]
-
-fltr.ramps.red = redid
-g.set_gamma_sync(fltr)
-time.sleep(0.5)
-fltr.ramps.red = redzero
-
-fltr.ramps.green = greenid
-g.set_gamma_sync(fltr)
-time.sleep(0.5)
-fltr.ramps.green = greenzero
-
-fltr.ramps.blue = blueid
-g.set_gamma_sync(fltr)
-time.sleep(0.5)
-
-g.set_nonbreaking(False)
-
-asynch = cg.AsyncContext()
-
-def flush(e):
-    if e.errno in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
-        while True:
-            try:
-                g.flush()
-            except OSError as ex:
-                if ex.errno in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
-                    continue
-                else:
-                    raise ex
-            break
-    else:
-        raise e
-
-try:
-    g.get_crtcs_send(asynch)
-except OSError as e:
-    flush(e)
-if g.synchronise([asynch]) != 0:
-     sys.exit(1)
-if g.get_crtcs_recv(asynch) != crtcs:
-    sys.exit(2)
-
-try:
-    g.get_gamma_info_send(crtc, asynch)
-except OSError as e:
-    flush(e)
-if g.synchronise([asynch]) != 0:
-     sys.exit(3)
-info2 = g.get_gamma_info_recv(asynch)
-if info2.cooperative != info.cooperative:
-    sys.exit(4)
-if info2.depth != info.depth:
-    sys.exit(4)
-if info2.supported != info.supported:
-    sys.exit(4)
-if info2.red_size != info.red_size:
-    sys.exit(4)
-if info2.green_size != info.green_size:
-    sys.exit(4)
-if info2.blue_size != info.blue_size:
-    sys.exit(4)
-if info2.colourspace != info.colourspace:
-    sys.exit(4)
-if (info2.gamut is None) != (info.gamut is None):
-    sys.exit(4)
-if info.gamut is not None:
-    if info2.gamut.red.x_raw != info.gamut.red.x_raw or info2.gamut.red.x != info.gamut.red.x:
-        sys.exit(4)
-    if info2.gamut.red.y_raw != info.gamut.red.y_raw or info2.gamut.red.y != info.gamut.red.y:
-        sys.exit(4)
-    if info2.gamut.green.x_raw != info.gamut.green.x_raw or info2.gamut.green.x != info.gamut.green.x:
-        sys.exit(4)
-    if info2.gamut.green.y_raw != info.gamut.green.y_raw or info2.gamut.green.y != info.gamut.green.y:
-        sys.exit(4)
-    if info2.gamut.blue.x_raw != info.gamut.blue.x_raw or info2.gamut.blue.x != info.gamut.blue.x:
-        sys.exit(4)
-    if info2.gamut.blue.y_raw != info.gamut.blue.y_raw or info2.gamut.blue.y != info.gamut.blue.y:
-        sys.exit(4)
-    if info2.gamut.white.x_raw != info.gamut.white.x_raw or info2.gamut.white.x != info.gamut.white.x:
-        sys.exit(4)
-    if info2.gamut.white.y_raw != info.gamut.white.y_raw or info2.gamut.white.y != info.gamut.white.y:
-        sys.exit(4)
-
-try:
-    g.set_gamma_send(cg.Filter(crtc = crtc, fclass = 'pylibcoopgamma::test::test',
-                               lifespan = cg.Lifespan.REMOVE), asynch)
-except OSError as e:
-    flush(e)
-if g.synchronise([asynch]) != 0:
-     sys.exit(1)
-g.set_gamma_recv(asynch)
-
-try:
-    g.get_gamma_send(cg.FilterQuery(crtc = crtc, coalesce = False), asynch)
-except OSError as e:
-    flush(e)
-if g.synchronise([asynch]) != 0:
-     sys.exit(5)
-table = g.get_gamma_recv(asynch)
-if table.red_size != table_nc.red_size:
-    sys.exit(6)
-if table.green_size != table_nc.green_size:
-    sys.exit(6)
-if table.blue_size != table_nc.blue_size:
-    sys.exit(6)
-if table.depth != table_nc.depth:
-    sys.exit(6)
-if len(table.filters) != len(table_nc.filters):
-    sys.exit(6)
-for i, (fltr1, fltr2) in enumerate(zip(table.filters, table_nc.filters)):
-    if fltr1.priority != fltr2.priority:
-        sys.exit(6)
-    if fltr1.fclass != fltr2.fclass:
-        sys.exit(6)
-    if fltr1.ramps.red != fltr2.ramps.red:
-        sys.exit(6)
-    if fltr1.ramps.green != fltr2.ramps.green:
-        sys.exit(6)
-    if fltr1.ramps.blue != fltr2.ramps.blue:
-        sys.exit(6)
-
-try:
-    g.get_gamma_send(cg.FilterQuery(crtc = crtc, coalesce = True), asynch)
-except OSError as e:
-    flush(e)
-if g.synchronise([asynch]) != 0:
-     sys.exit(7)
-table = g.get_gamma_recv(asynch)
-if table.red_size != table_c.red_size:
-    sys.exit(8)
-if table.green_size != table_c.green_size:
-    sys.exit(8)
-if table.blue_size != table_c.blue_size:
-    sys.exit(8)
-if table.depth != table_c.depth:
-    sys.exit(8)
-if len(table.filters) != len(table_c.filters):
-    sys.exit(8)
-for i, (fltr1, fltr2) in enumerate(zip(table.filters, table_c.filters)):
-    if fltr1.ramps.red != fltr2.ramps.red:
-        sys.exit(8)
-    if fltr1.ramps.green != fltr2.ramps.green:
-        sys.exit(8)
-    if fltr1.ramps.blue != fltr2.ramps.blue:
-        sys.exit(8)
-
-
-fltr = cg.Filter(0, crtc, 'pylibcoopgamma::test::test', cg.Lifespan.UNTIL_DEATH, table.depth,
-                 cg.Ramps(table.red_size, table.green_size, table.blue_size))
-
-fltr.ramps.red = list(reversed(redid))
-fltr.ramps.green = list(reversed(greenid))
-fltr.ramps.blue = list(reversed(blueid))
-try:
-    g.set_gamma_send(fltr, asynch)
-except OSError as e:
-    flush(e)
-if g.synchronise([asynch]) != 0:
-    sys.exit(9)
-g.skip_message()
-time.sleep(0.5)
-
-fltr.ramps.red = redid
-fltr.ramps.green = greenid
-fltr.ramps.blue = blueid
-g.set_gamma_sync(fltr)
-
-g.set_nonbreaking(True)
-
-async1 = asynch
-async2 = cg.AsyncContext()
-async3 = cg.AsyncContext()
-time.sleep(0.5)
-
-fltr.ramps.red = list(reversed(redid))
-fltr.fclass = 'pylibcoopgamma::test::red'
-try:
-    g.set_gamma_send(fltr, async1)
-    need_flush = True
-except OSError as e:
-    if e.errno not in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
-        sys.exit(10)
-    need_flush = False
-fltr.ramps.red = redid
-
-fltr.ramps.green = list(reversed(greenid))
-fltr.fclass = 'pylibcoopgamma::test::green'
-try:
-    g.set_gamma_send(fltr, async2)
-    need_flush = True
-except OSError as e:
-    if e.errno not in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
-        sys.exit(10)
-    need_flush = False
-fltr.ramps.green = greenid
-
-fltr.ramps.blue = list(reversed(blueid))
-fltr.fclass = 'pylibcoopgamma::test::blue'
-try:
-    g.set_gamma_send(fltr, async3)
-    need_flush = True
-except OSError as e:
-    if e.errno not in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
-        sys.exit(10)
-    need_flush = False
-fltr.ramps.blue = blueid
-
-while need_flush:
-    try:
-        g.flush()
-        break
-    except OSError as e:
-        if e.errno in (errno.EINTR, errno.EWOULDBLOCK, errno.EAGAIN):
-            continue
-        else:
-            sys.exit(11)
-
-poll = select.poll()
-poll.register(g.fd, select.POLLIN | select.POLLPRI)
-
-unsynced = [True] * 3
-while any(unsynced):
-    poll.poll()
-    n = g.synchronise([async1, async2, async3])
-    if n < 0 or n >= 3 or not unsynced[n]:
-        sys.exit(12)
-    unsynced[n] = False
-    g.set_gamma_recv([async1, async2, async3][n])
-
-time.sleep(0.5)
-del g
-