add class gamma ramps

Signed-off-by: Mattias Andrée <maandree@operamail.com>

3 files changed, 888 insertions, 0 deletions

diff --git a/src/c.pyx b/src/c.pyx
new file mode 100644
index 0000000..f38ce6a
--- /dev/null
+++ b/src/c.pyx
@@ -0,0 +1,37 @@
+# -*- python -*-
+'''
+pylibgamma — Python 3 wrapper for libgamma
+Copyright © 2014  Mattias Andrée (maandree@member.fsf.org)
+
+This library is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this library.  If not, see <http://www.gnu.org/licenses/>.
+'''
+
+cimport cython
+
+from libc.string cimport strerror as c_strerror
+
+
+def strerror(error : int) -> str:
+    '''
+    Get a textual description of an error.
+    
+    @param   error  The number of the error.
+    @return         The description of the error.
+    '''
+    cdef const char* text
+    cdef bytes bs
+    text = c_strerror(<int>error)
+    bs = text
+    return bs.decode('utf-8', 'strict')
+
diff --git a/src/libgamma_method.py b/src/libgamma_method.py
index 8e7ebdd..ce92adb 100644
--- a/src/libgamma_method.py
+++ b/src/libgamma_method.py
@@ -570,3 +570,202 @@ that required there is a monitor attached to the connector,
 and that status itself.
 '''
 
+
+
+class GammaRamps:
+    '''
+    Gamma ramp structure.
+    '''
+    
+    def __init__(self, red_size : int, green_size : int = ..., blue_size : int = ..., *, depth : int = 16):
+        '''
+        Constructor.
+        
+        @param  red_size    The number of stops in the gamma ramp for the red channel
+        @param  green_size  The number of stops in the gamma ramp for the green channel, `...` for `red_size`
+        @param  blue_size   The number of stops in the gamma ramp for the blue channel, `...` for `green_size`
+        @param  depth       The depth of the gamma ramps
+        '''
+        if green_size is ...:  green_size = red_size
+        if blue_size is ...:   blue_size = green_size
+        
+        self.__depth = depth
+        if depth not in (8, 16, 32, 64, -1, -2):
+            raise ValueError('invalid gamma ramp depth')
+        
+        if   depth ==  8:  ramp_struct = libgamma_native_gamma_ramps8_create (red_size, green_size, blue_size)
+        elif depth == 16:  ramp_struct = libgamma_native_gamma_ramps16_create(red_size, green_size, blue_size)
+        elif depth == 32:  ramp_struct = libgamma_native_gamma_ramps32_create(red_size, green_size, blue_size)
+        elif depth == 64:  ramp_struct = libgamma_native_gamma_ramps64_create(red_size, green_size, blue_size)
+        elif depth == -1:  ramp_struct = libgamma_native_gamma_rampsf_create (red_size, green_size, blue_size)
+        elif depth == -2:  ramp_struct = libgamma_native_gamma_rampsd_create (red_size, green_size, blue_size)
+        if isinstance(ramp_struct, int):
+            import c
+            error = OSError()
+            error.errno = ramp_struct
+            error.strerror = c.strerror(error.errno)
+            raise error
+        (self.__ramps, red, green, blue) = ramp_struct
+        
+        class Ramp:
+            '''
+            A gamma ramp for one single channel.
+            '''
+            
+            def __init__(self, ramp, size : int, depth : int):
+                '''
+                Constructor.
+                
+                @param  ramp   The gamma ramp.
+                @param  size   The number of stops in the gamma ramp.
+                @param  depth  The depth of the gamma ramp.
+                '''
+                self.__size = size
+                self.__ramp = ramp
+                if   depth ==  8:  fs = (libgamma_native_gamma_ramps8_get,  libgamma_native_gamma_ramps8_set)
+                elif depth == 16:  fs = (libgamma_native_gamma_ramps16_get, libgamma_native_gamma_ramps16_set)
+                elif depth == 32:  fs = (libgamma_native_gamma_ramps32_get, libgamma_native_gamma_ramps32_set)
+                elif depth == 64:  fs = (libgamma_native_gamma_ramps64_get, libgamma_native_gamma_ramps64_set)
+                elif depth == -1:  fs = (libgamma_native_gamma_rampsf_get,  libgamma_native_gamma_rampsf_set)
+                elif depth == -2:  fs = (libgamma_native_gamma_rampsd_get,  libgamma_native_gamma_rampsd_set)
+                (self.__get, self.__set) = fs
+            
+            
+            @property
+            def size(self) -> int:
+                '''
+                Get the number of stops in the gamma ramp.
+                
+                @return  The number of stops in the gamma ramp.
+                '''
+                return self.__size
+            
+            @size.setter
+            def size(self, value : int):
+                '''
+                It is not possible to change this attribute, but a setter is
+                required for the getter to function.
+                '''
+                raise AttributeError('cannot resize ramp')
+            
+            def __len__(self) -> int:
+                '''
+                Get the number of stops in the gamma ramp.
+                
+                @return  The number of stops in the gamma ramp.
+                '''
+                return self.__size
+            
+            def __getitem__(self, indices):
+                '''
+                Read the gamma ramp.
+                
+                @param   indices:slice     The stops to read.
+                @return  :list<int|float>  The values of the read stops.
+                
+                -- OR --
+                
+                @param   indices:int  The index of the stop to read.
+                @return  :int|float   The value of the read stop.
+                '''
+                if isinstance(indices, slice):
+                    start = indices.start
+                    stop = indices.stop
+                    step = indices.step
+                    if start is None:  start = 0
+                    elif start < 0:    start += self.__size
+                    if stop is None:   stop = self.__size
+                    elif stop < 0:     stop += self.__size
+                    if step is None:   step = 1
+                    return [self.__get(self.__ramp, i) for i in range(start, stop, step)]
+                else:
+                    if indices < 0:
+                        indices += self.__size
+                    return self.__get(self.__ramp, indices)
+            
+            def __setitem__(self, indices, values):
+                '''
+                Modify the gamma ramp.
+                
+                @param  indices:slice          The stops to modify.
+                @param  values:itr<int|float>  The values for the selected stops.
+                
+                -- OR --
+                
+                @param  indices:int        The index of the stop to modify.
+                @param  values:int|float   The new value for the stop.
+                '''
+                if isinstance(indices, slice):
+                    start = indices.start
+                    stop = indices.stop
+                    step = indices.step
+                    if start is None:  start = 0
+                    elif start < 0:    start += self.__size
+                    if stop is None:   stop = self.__size
+                    elif stop < 0:     stop += self.__size
+                    if step is None:   step = 1
+                    indices = list(range(start, stop, step))
+                    if not len(indices) == len(values):
+                        raise ValueError('cannot resize ramp')
+                    for index, value in zip(indices, values):
+                        self.__set(self.__ramp, index, value)
+                else:
+                    if indices < 0:
+                        indices += self.__size
+                    self.__set(self.__ramp, indices, values)
+        
+        self.red   = Ramp(red,   red_size,   depth)
+        self.green = Ramp(green, green_size, depth)
+        self.blue  = Ramp(blue,  blue_size,  depth)
+    
+    
+    def __del__(self):
+        '''
+        This function is called when the object is not longer in use.
+        '''
+        if   self.__depth ==  8:  libgamma_native_gamma_ramps8_free(self.__ramps)
+        elif self.__depth == 16:  libgamma_native_gamma_ramps16_free(self.__ramps)
+        elif self.__depth == 32:  libgamma_native_gamma_ramps32_free(self.__ramps)
+        elif self.__depth == 64:  libgamma_native_gamma_ramps64_free(self.__ramps)
+        elif self.__depth == -1:  libgamma_native_gamma_rampsf_free(self.__ramps)
+        elif self.__depth == -2:  libgamma_native_gamma_rampsd_free(self.__ramps)
+    
+    
+    @property
+    def size(self) -> tuple:
+        '''
+        Get the ramps' sizes.
+        
+        @return  :(red:int, green:int, blue:int)  The size of each individual ramp.
+        '''
+        return (self.red.size, self.green.size, self.blue.size)
+    
+    
+    @size.setter
+    def size(self, value):
+        '''
+        It is not possible to change this attribute, but a setter is
+        required for the getter to function.
+        '''
+        raise AttributeError('cannot resize ramps')
+    
+    
+    @property
+    def depth(self) -> int:
+        '''
+        Get the depth of ramps.
+        
+        @return  :int  The ramps' depth in bits and -1 for single precision floating
+                       point and -2 for doublesingle precision floating point
+        '''
+        return self.__depth
+    
+    
+    @size.setter
+    def depth(self, value):
+        '''
+        It is not possible to change this attribute, but a setter is
+        required for the getter to function.
+        '''
+        raise AttributeError('cannot change depth')
+
diff --git a/src/libgamma_native_method.pyx b/src/libgamma_native_method.pyx
new file mode 100644
index 0000000..7e9a867
--- /dev/null
+++ b/src/libgamma_native_method.pyx
@@ -0,0 +1,652 @@
+# -*- python -*-
+'''
+pylibgamma — Python 3 wrapper for libgamma
+Copyright © 2014  Mattias Andrée (maandree@member.fsf.org)
+
+This library is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this library.  If not, see <http://www.gnu.org/licenses/>.
+'''
+
+cimport cython
+
+from libc.stdint cimport *
+from libc.stdlib cimport malloc
+from libc.stddef cimport size_t
+from libc.errno cimport errno
+
+
+cdef extern from "libgamma/libgamma-method.h":
+    ctypedef struct libgamma_gamma_ramps8_t:
+        # Gamma ramp structure for 8-bit gamma ramps.
+        size_t red_size
+        # The size of `red`.
+        size_t green_size
+        # The size of `green`.
+        size_t blue_size
+        # The size of `blue`.
+        uint8_t* red
+        # The gamma ramp for the red channel.
+        uint8_t* green
+        # The gamma ramp for the green channel.
+        uint8_t* blue
+        # The gamma ramp for the blue channel.
+    
+    ctypedef struct libgamma_gamma_ramps16_t:
+        # Gamma ramp structure for 16-bit gamma ramps.
+        size_t red_size
+        # The size of `red`.
+        size_t green_size
+        # The size of `green`.
+        size_t blue_size
+        # The size of `blue`.
+        uint16_t* red
+        # The gamma ramp for the red channel.
+        uint16_t* green
+        # The gamma ramp for the green channel.
+        uint16_t* blue
+        # The gamma ramp for the blue channel.
+    
+    ctypedef struct libgamma_gamma_ramps32_t:
+        # Gamma ramp structure for 32-bit gamma ramps.
+        size_t red_size
+        # The size of `red`.
+        size_t green_size
+        # The size of `green`.
+        size_t blue_size
+        # The size of `blue`.
+        uint32_t* red
+        # The gamma ramp for the red channel.
+        uint32_t* green
+        # The gamma ramp for the green channel.
+        uint32_t* blue
+        # The gamma ramp for the blue channel.
+    
+    ctypedef struct libgamma_gamma_ramps64_t:
+        # Gamma ramp structure for 64-bit gamma ramps.
+        size_t red_size
+        # The size of `red`.
+        size_t green_size
+        # The size of `green`.
+        size_t blue_size
+        # The size of `blue`.
+        uint64_t* red
+        # The gamma ramp for the red channel.
+        uint64_t* green
+        # The gamma ramp for the green channel.
+        uint64_t* blue
+        # The gamma ramp for the blue channel.
+    
+    ctypedef struct libgamma_gamma_rampsf_t:
+        # Gamma ramp structure for `float` gamma ramps.
+        size_t red_size
+        # The size of `red`.
+        size_t green_size
+        # The size of `green`.
+        size_t blue_size
+        # The size of `blue`.
+        float* red
+        # The gamma ramp for the red channel.
+        float* green
+        # The gamma ramp for the green channel.
+        float* blue
+        # The gamma ramp for the blue channel.
+    
+    ctypedef struct libgamma_gamma_rampsd_t:
+        # Gamma ramp structure for `double` gamma ramps.
+        size_t red_size
+        # The size of `red`.
+        size_t green_size
+        # The size of `green`.
+        size_t blue_size
+        # The size of `blue`.
+        double* red
+        # The gamma ramp for the red channel.
+        double* green
+        # The gamma ramp for the green channel.
+        double* blue
+        # The gamma ramp for the blue channel.
+
+
+cdef extern int libgamma_gamma_ramps8_initialise(libgamma_gamma_ramps8_t* this)
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation.
+
+The input must have `red_size`, `green_size` and `blue_size` set to the
+sizes of the gamma ramps that should be allocated.
+
+@param   this  The gamma ramps.
+@return        Zero on success, -1 on allocation error, `errno` will be set accordingly.
+'''
+
+cdef extern void libgamma_gamma_ramps8_free(libgamma_gamma_ramps8_t* this)
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps8_initialise` or otherwise
+initialises in the proper manner, as well as release the pointer
+to the structure.
+
+@param  this  The gamma ramps.
+'''
+
+
+cdef extern int libgamma_gamma_ramps16_initialise(libgamma_gamma_ramps16_t* this)
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation.
+
+The input must have `red_size`, `green_size` and `blue_size` set to the
+sizes of the gamma ramps that should be allocated.
+
+@param   this  The gamma ramps.
+@return        Zero on success, -1 on allocation error, `errno` will be set accordingly.
+'''
+
+cdef extern void libgamma_gamma_ramps16_free(libgamma_gamma_ramps16_t* this)
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps16_initialise` or otherwise
+initialises in the proper manner, as well as release the pointer
+to the structure.
+
+@param  this  The gamma ramps.
+'''
+
+
+cdef extern int libgamma_gamma_ramps32_initialise(libgamma_gamma_ramps32_t* this)
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation.
+
+The input must have `red_size`, `green_size` and `blue_size` set to the
+sizes of the gamma ramps that should be allocated.
+
+@param   this  The gamma ramps.
+@return        Zero on success, -1 on allocation error, `errno` will be set accordingly.
+'''
+
+cdef extern void libgamma_gamma_ramps32_free(libgamma_gamma_ramps32_t* this)
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps32_initialise` or otherwise
+initialises in the proper manner, as well as release the pointer
+to the structure.
+
+@param  this  The gamma ramps.
+'''
+
+
+cdef extern int libgamma_gamma_ramps64_initialise(libgamma_gamma_ramps64_t* this)
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation.
+
+The input must have `red_size`, `green_size` and `blue_size` set to the
+sizes of the gamma ramps that should be allocated.
+
+@param   this  The gamma ramps.
+@return        Zero on success, -1 on allocation error, `errno` will be set accordingly.
+'''
+
+cdef extern void libgamma_gamma_ramps64_free(libgamma_gamma_ramps64_t* this)
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_ramps64_initialise` or otherwise
+initialises in the proper manner, as well as release the pointer
+to the structure.
+
+@param  this  The gamma ramps.
+'''
+
+
+cdef extern int libgamma_gamma_rampsf_initialise(libgamma_gamma_rampsf_t* this)
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation.
+
+The input must have `red_size`, `green_size` and `blue_size` set to the
+sizes of the gamma ramps that should be allocated.
+
+@param   this  The gamma ramps.
+@return        Zero on success, -1 on allocation error, `errno` will be set accordingly.
+'''
+
+cdef extern void libgamma_gamma_rampsf_free(libgamma_gamma_rampsf_t* this)
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_rampsf_initialise` or otherwise
+initialises in the proper manner, as well as release the pointer
+to the structure.
+
+@param  this  The gamma ramps.
+'''
+
+
+cdef extern int libgamma_gamma_rampsd_initialise(libgamma_gamma_rampsd_t* this)
+'''
+Initialise a gamma ramp in the proper way that allows all adjustment
+methods to read from and write to it without causing segmentation violation.
+
+The input must have `red_size`, `green_size` and `blue_size` set to the
+sizes of the gamma ramps that should be allocated.
+
+@param   this  The gamma ramps
+@return        Zero on success, -1 on allocation error, `errno` will be set accordingly.
+'''
+
+cdef extern void libgamma_gamma_rampsd_free(libgamma_gamma_rampsd_t* this)
+'''
+Release resources that are held by a gamma ramp strcuture that
+has been allocated by `libgamma_gamma_rampsd_initialise` or otherwise
+initialises in the proper manner, as well as release the pointer
+to the structure.
+
+@param  this  The gamma ramps.
+'''
+
+
+
+def libgamma_native_gamma_ramps8_create(red_size : int, green_size : int, blue_size : int):
+    '''
+    Create a gamma ramp in the proper way that allows all adjustment
+    methods to read from and write to it without causing segmentation violation.
+    
+    @param   red_size       The size of the gamma ramp for the red channel
+    @param   green_size     The size of the gamma ramp for the green channel
+    @param   blue_size      The size of the gamma ramp for the blue channel
+    @return  :(int){4}|int  The tuple that describes the created data, `errno` on failure:
+                              Element 1:  The address of the gamma ramp structure
+                              Element 2:  The address of the gamma ramp for the red channel
+                              Element 3:  The address of the gamma ramp for the green channel
+                              Element 4:  The address of the gamma ramp for the blue channel
+    '''
+    cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps8_t))
+    cdef libgamma_gamma_ramps8_t* item = <libgamma_gamma_ramps8_t*>allocation
+    cdef size_t red, green, blue
+    if item == NULL:
+        return errno
+    red   = <size_t><void*>(item.red)
+    green = <size_t><void*>(item.green)
+    blue  = <size_t><void*>(item.blue)
+    return (int(<size_t>allocation), int(red), int(blue), int(blue))
+
+
+def libgamma_native_gamma_ramps8_free(this : int):
+    '''
+    Release resources that are held by a gamma ramp strcuture that
+    has been allocated by `libgamma_native_gamma_ramps8_create` or otherwise
+    created in the proper manner, as well as release the pointer
+    to the structure.
+    
+    @param  this  The gamma ramps.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef libgamma_gamma_ramps8_t* item = <libgamma_gamma_ramps8_t*>address
+    libgamma_gamma_ramps8_free(item)
+
+
+def libgamma_native_gamma_ramps8_get(this : int, index : int) -> int:
+    '''
+    Read a stop in a gamma ramp.
+    
+    @param   this   The gamma ramp.
+    @param   index  The index of the gamma ramp stop.
+    @return         The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint8_t* ramp = <uint8_t*>address
+    return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps8_set(this : int, index : int, value : int):
+    '''
+    Modify a stop in a gamma ramp.
+    
+    @param  this   The gamma ramp.
+    @param  index  The index of the gamma ramp stop.
+    @param  value  The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint8_t* ramp = <uint8_t*>address
+    ramp[<size_t>index] = <uint8_t>value
+
+
+
+def libgamma_native_gamma_ramps16_create(red_size : int, green_size : int, blue_size : int):
+    '''
+    Create a gamma ramp in the proper way that allows all adjustment
+    methods to read from and write to it without causing segmentation violation.
+    
+    @param   red_size       The size of the gamma ramp for the red channel
+    @param   green_size     The size of the gamma ramp for the green channel
+    @param   blue_size      The size of the gamma ramp for the blue channel
+    @return  :(int){4}|int  The tuple that describes the created data, `errno` on failure:
+                              Element 1:  The address of the gamma ramp structure
+                              Element 2:  The address of the gamma ramp for the red channel
+                              Element 3:  The address of the gamma ramp for the green channel
+                              Element 4:  The address of the gamma ramp for the blue channel
+    '''
+    cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps16_t))
+    cdef libgamma_gamma_ramps16_t* item = <libgamma_gamma_ramps16_t*>allocation
+    cdef size_t red, green, blue
+    if item == NULL:
+        return errno
+    red   = <size_t><void*>(item.red)
+    green = <size_t><void*>(item.green)
+    blue  = <size_t><void*>(item.blue)
+    return (int(<size_t>allocation), int(red), int(blue), int(blue))
+
+
+def libgamma_native_gamma_ramps16_free(this : int):
+    '''
+    Release resources that are held by a gamma ramp strcuture that
+    has been allocated by `libgamma_native_gamma_ramps16_create` or otherwise
+    created in the proper manner, as well as release the pointer
+    to the structure.
+    
+    @param  this  The gamma ramps.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef libgamma_gamma_ramps16_t* item = <libgamma_gamma_ramps16_t*>address
+    libgamma_gamma_ramps16_free(item)
+
+
+def libgamma_native_gamma_ramps16_get(this : int, index : int) -> int:
+    '''
+    Read a stop in a gamma ramp.
+    
+    @param   this   The gamma ramp.
+    @param   index  The index of the gamma ramp stop.
+    @return         The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint16_t* ramp = <uint16_t*>address
+    return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps16_set(this : int, index : int, value : int):
+    '''
+    Modify a stop in a gamma ramp.
+    
+    @param  this   The gamma ramp.
+    @param  index  The index of the gamma ramp stop.
+    @param  value  The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint16_t* ramp = <uint16_t*>address
+    ramp[<size_t>index] = <uint16_t>value
+
+
+
+def libgamma_native_gamma_ramps32_create(red_size : int, green_size : int, blue_size : int):
+    '''
+    Create a gamma ramp in the proper way that allows all adjustment
+    methods to read from and write to it without causing segmentation violation.
+    
+    @param   red_size       The size of the gamma ramp for the red channel
+    @param   green_size     The size of the gamma ramp for the green channel
+    @param   blue_size      The size of the gamma ramp for the blue channel
+    @return  :(int){4}|int  The tuple that describes the created data, `errno` on failure:
+                              Element 1:  The address of the gamma ramp structure
+                              Element 2:  The address of the gamma ramp for the red channel
+                              Element 3:  The address of the gamma ramp for the green channel
+                              Element 4:  The address of the gamma ramp for the blue channel
+    '''
+    cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps32_t))
+    cdef libgamma_gamma_ramps32_t* item = <libgamma_gamma_ramps32_t*>allocation
+    cdef size_t red, green, blue
+    if item == NULL:
+        return errno
+    red   = <size_t><void*>(item.red)
+    green = <size_t><void*>(item.green)
+    blue  = <size_t><void*>(item.blue)
+    return (int(<size_t>allocation), int(red), int(blue), int(blue))
+
+
+def libgamma_native_gamma_ramps32_free(this : int):
+    '''
+    Release resources that are held by a gamma ramp strcuture that
+    has been allocated by `libgamma_native_gamma_ramps32_create` or otherwise
+    created in the proper manner, as well as release the pointer
+    to the structure.
+    
+    @param  this  The gamma ramps.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef libgamma_gamma_ramps32_t* item = <libgamma_gamma_ramps32_t*>address
+    libgamma_gamma_ramps32_free(item)
+
+
+def libgamma_native_gamma_ramps32_get(this : int, index : int) -> int:
+    '''
+    Read a stop in a gamma ramp.
+    
+    @param   this   The gamma ramp.
+    @param   index  The index of the gamma ramp stop.
+    @return         The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint32_t* ramp = <uint32_t*>address
+    return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps32_set(this : int, index : int, value : int):
+    '''
+    Modify a stop in a gamma ramp.
+    
+    @param  this   The gamma ramp.
+    @param  index  The index of the gamma ramp stop.
+    @param  value  The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint32_t* ramp = <uint32_t*>address
+    ramp[<size_t>index] = <uint32_t>value
+
+
+
+def libgamma_native_gamma_ramps64_create(red_size : int, green_size : int, blue_size : int):
+    '''
+    Create a gamma ramp in the proper way that allows all adjustment
+    methods to read from and write to it without causing segmentation violation.
+    
+    @param   red_size       The size of the gamma ramp for the red channel
+    @param   green_size     The size of the gamma ramp for the green channel
+    @param   blue_size      The size of the gamma ramp for the blue channel
+    @return  :(int){4}|int  The tuple that describes the created data, `errno` on failure:
+                              Element 1:  The address of the gamma ramp structure
+                              Element 2:  The address of the gamma ramp for the red channel
+                              Element 3:  The address of the gamma ramp for the green channel
+                              Element 4:  The address of the gamma ramp for the blue channel
+    '''
+    cdef void* allocation = malloc(sizeof(libgamma_gamma_ramps64_t))
+    cdef libgamma_gamma_ramps64_t* item = <libgamma_gamma_ramps64_t*>allocation
+    cdef size_t red, green, blue
+    if item == NULL:
+        return errno
+    red   = <size_t><void*>(item.red)
+    green = <size_t><void*>(item.green)
+    blue  = <size_t><void*>(item.blue)
+    return (int(<size_t>allocation), int(red), int(blue), int(blue))
+
+
+def libgamma_native_gamma_ramps64_free(this : int):
+    '''
+    Release resources that are held by a gamma ramp strcuture that
+    has been allocated by `libgamma_native_gamma_ramps64_create` or otherwise
+    created in the proper manner, as well as release the pointer
+    to the structure.
+    
+    @param  this  The gamma ramps.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef libgamma_gamma_ramps64_t* item = <libgamma_gamma_ramps64_t*>address
+    libgamma_gamma_ramps64_free(item)
+
+
+def libgamma_native_gamma_ramps64_get(this : int, index : int) -> int:
+    '''
+    Read a stop in a gamma ramp.
+    
+    @param   this   The gamma ramp.
+    @param   index  The index of the gamma ramp stop.
+    @return         The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint64_t* ramp = <uint64_t*>address
+    return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_ramps64_set(this : int, index : int, value : int):
+    '''
+    Modify a stop in a gamma ramp.
+    
+    @param  this   The gamma ramp.
+    @param  index  The index of the gamma ramp stop.
+    @param  value  The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef uint64_t* ramp = <uint64_t*>address
+    ramp[<size_t>index] = <uint64_t>value
+
+
+
+def libgamma_native_gamma_rampsf_create(red_size : int, green_size : int, blue_size : int):
+    '''
+    Create a gamma ramp in the proper way that allows all adjustment
+    methods to read from and write to it without causing segmentation violation.
+    
+    @param   red_size       The size of the gamma ramp for the red channel
+    @param   green_size     The size of the gamma ramp for the green channel
+    @param   blue_size      The size of the gamma ramp for the blue channel
+    @return  :(int){4}|int  The tuple that describes the created data, `errno` on failure:
+                              Element 1:  The address of the gamma ramp structure
+                              Element 2:  The address of the gamma ramp for the red channel
+                              Element 3:  The address of the gamma ramp for the green channel
+                              Element 4:  The address of the gamma ramp for the blue channel
+    '''
+    cdef void* allocation = malloc(sizeof(libgamma_gamma_rampsf_t))
+    cdef libgamma_gamma_rampsf_t* item = <libgamma_gamma_rampsf_t*>allocation
+    cdef size_t red, green, blue
+    if item == NULL:
+        return errno
+    red   = <size_t><void*>(item.red)
+    green = <size_t><void*>(item.green)
+    blue  = <size_t><void*>(item.blue)
+    return (int(<size_t>allocation), int(red), int(blue), int(blue))
+
+
+def libgamma_native_gamma_rampsf_free(this : int):
+    '''
+    Release resources that are held by a gamma ramp strcuture that
+    has been allocated by `libgamma_native_gamma_rampsf_create` or otherwise
+    created in the proper manner, as well as release the pointer
+    to the structure.
+    
+    @param  this  The gamma ramps.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef libgamma_gamma_rampsf_t* item = <libgamma_gamma_rampsf_t*>address
+    libgamma_gamma_rampsf_free(item)
+
+
+def libgamma_native_gamma_rampsf_get(this : int, index : int) -> int:
+    '''
+    Read a stop in a gamma ramp.
+    
+    @param   this   The gamma ramp.
+    @param   index  The index of the gamma ramp stop.
+    @return         The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef float* ramp = <float*>address
+    return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_rampsf_set(this : int, index : int, value : int):
+    '''
+    Modify a stop in a gamma ramp.
+    
+    @param  this   The gamma ramp.
+    @param  index  The index of the gamma ramp stop.
+    @param  value  The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef float* ramp = <float*>address
+    ramp[<size_t>index] = <float>value
+
+
+
+def libgamma_native_gamma_rampsd_create(red_size : int, green_size : int, blue_size : int):
+    '''
+    Create a gamma ramp in the proper way that allows all adjustment
+    methods to read from and write to it without causing segmentation violation.
+    
+    @param   red_size       The size of the gamma ramp for the red channel
+    @param   green_size     The size of the gamma ramp for the green channel
+    @param   blue_size      The size of the gamma ramp for the blue channel
+    @return  :(int){4}|int  The tuple that describes the created data, `errno` on failure:
+                              Element 1:  The address of the gamma ramp structure
+                              Element 2:  The address of the gamma ramp for the red channel
+                              Element 3:  The address of the gamma ramp for the green channel
+                              Element 4:  The address of the gamma ramp for the blue channel
+    '''
+    cdef void* allocation = malloc(sizeof(libgamma_gamma_rampsd_t))
+    cdef libgamma_gamma_rampsd_t* item = <libgamma_gamma_rampsd_t*>allocation
+    cdef size_t red, green, blue
+    if item == NULL:
+        return errno
+    red   = <size_t><void*>(item.red)
+    green = <size_t><void*>(item.green)
+    blue  = <size_t><void*>(item.blue)
+    return (int(<size_t>allocation), int(red), int(blue), int(blue))
+
+
+def libgamma_native_gamma_rampsd_free(this : int):
+    '''
+    Release resources that are held by a gamma ramp strcuture that
+    has been allocated by `libgamma_native_gamma_rampsd_create` or otherwise
+    created in the proper manner, as well as release the pointer
+    to the structure.
+    
+    @param  this  The gamma ramps.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef libgamma_gamma_rampsd_t* item = <libgamma_gamma_rampsd_t*>address
+    libgamma_gamma_rampsd_free(item)
+
+
+def libgamma_native_gamma_rampsd_get(this : int, index : int) -> int:
+    '''
+    Read a stop in a gamma ramp.
+    
+    @param   this   The gamma ramp.
+    @param   index  The index of the gamma ramp stop.
+    @return         The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef double* ramp = <double*>address
+    return int(ramp[<size_t>index])
+
+
+def libgamma_native_gamma_rampsd_set(this : int, index : int, value : int):
+    '''
+    Modify a stop in a gamma ramp.
+    
+    @param  this   The gamma ramp.
+    @param  index  The index of the gamma ramp stop.
+    @param  value  The value of the gamma ramp stop.
+    '''
+    cdef void* address = <void*><size_t>this
+    cdef double* ramp = <double*>address
+    ramp[<size_t>index] = <double>value
+