Change style1.0.2

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

1 files changed, 447 insertions, 434 deletions

diff --git a/libgamma-facade.cc b/libgamma-facade.cc
index 9d74d6f..dfb07f3 100644
--- a/libgamma-facade.cc
+++ b/libgamma-facade.cc
@@ -1,443 +1,456 @@
 /* See LICENSE file for copyright and license details. */
 #include "libgamma-facade.hh"
-
 #include "libgamma-error.hh"
-
 #include <cstdlib>
 
 
 namespace libgamma
 {
-  /**
-   * List available adjustment methods by their order of preference based on the environment.
-   * 
-   * @param  operation  Allowed values:
-   *                      0: Methods that the environment suggests will work, excluding fake.
-   *                      1: Methods that the environment suggests will work, including fake.
-   *                      2: All real non-fake methods.
-   *                      3: All real methods.
-   *                      4: All methods.
-   *                    Other values invoke undefined behaviour.
-   * @return            Array of methods.
-   */
-  std::vector<int> list_methods(int operation)
-  {
-    int* methods = (int*)malloc(LIBGAMMA_METHOD_COUNT * sizeof(int));
-    size_t n, i;
-    std::vector<int> rc;
-    
-    n = libgamma_list_methods(methods, LIBGAMMA_METHOD_COUNT, operation);
-    if (n > LIBGAMMA_METHOD_COUNT)
-      {
-	free(methods);
-	methods = (int*)malloc(n * sizeof(int));
-	libgamma_list_methods(methods, n, operation);
-      }
-    
-    for (i = 0; i < n; i++)
-      rc.push_back(methods[i]);
-    
-    free(methods);
-    return rc;
-  }
-  
-  /**
-   * Check whether an adjustment method is available, non-existing (invalid) methods will be
-   * identified as not available under the rationale that the library may be out of date.
-   * 
-   * @param   method  The adjustment method.
-   * @return          Whether the adjustment method is available.
-   */
-  int is_method_available(int method)
-  {
-    return libgamma_is_method_available(method);
-  }
-  
-  /**
-   * Return the capabilities of an adjustment method.
-   * 
-   * @param  output  The data structure to fill with the method's capabilities,
-   * @param  method  The adjustment method (display server and protocol).
-   */
-  void method_capabilities(MethodCapabilities* output, int method)
-  {
-    libgamma_method_capabilities_t caps;
-    libgamma_method_capabilities(&caps, method);
-    *output = MethodCapabilities(&caps);
-  }
-  
-  /**
-   * Return the default site for an adjustment method.
-   * 
-   * @param   method  The adjustment method (display server and protocol.)
-   * @return          The default site, `nullptr` if it cannot be determined or if
-   *                  multiple sites are not supported by the adjustment method.
-   */
-  std::string* method_default_site(int method)
-  {
-    char* cstr = libgamma_method_default_site(method);
-    if (cstr == nullptr)
-      return nullptr;
-    return new std::string(cstr);
-  }
-  
-  /**
-   * Return the default variable that determines
-   * the default site for an adjustment method.
-   * 
-   * @param   method  The adjustment method (display server and protocol.)
-   * @return          The environ variables that is used to determine the
-   *                  default site. `nullptr` if there is none, that is, if
-   *                  the method does not support multiple sites.
-   *                  This value should not be `free`:d.
-   */
-  std::string* method_default_site_variable(int method)
-  {
-    const char* cstr = libgamma_method_default_site_variable(method);
-    if (cstr == nullptr)
-      return nullptr;
-    return new std::string(cstr);
-  }
-  
-  
-  /**
-   * Convert a raw representation of an EDID to a lowercase hexadecimal representation.
-   * 
-   * @param   edid    The EDID in raw representation.
-   * @param   length  The length of `edid`.
-   * @return          The EDID in lowercase hexadecimal representation.
-   */
-  std::string behex_edid(const unsigned char* edid, size_t length)
-  {
-    return behex_edid_lowercase(edid, length);
-  }
-  
-  /**
-   * Convert a raw representation of an EDID to a lowercase hexadecimal representation.
-   * 
-   * @param   edid    The EDID in raw representation.
-   * @param   length  The length of `edid`.
-   * @return          The EDID in lowercase hexadecimal representation.
-   */
-  std::string behex_edid_lowercase(const unsigned char* edid, size_t length)
-  {
-    char* cstr = libgamma_behex_edid_lowercase(edid, length);
-    std::string rc = std::string(cstr);
-    free(cstr);
-    return rc;
-  }
-  
-  /**
-   * Convert a raw representation of an EDID to an uppercase hexadecimal representation.
-   * 
-   * @param   edid    The EDID in raw representation.
-   * @param   length  The length of `edid`.
-   * @return          The EDID in uppercase hexadecimal representation.
-   */
-  std::string behex_edid_uppercase(const unsigned char* edid, size_t length)
-  {
-    char* cstr = libgamma_behex_edid_uppercase(edid, length);
-    std::string rc = std::string(cstr);
-    free(cstr);
-    return rc;
-  }
-  
-  /**
-   * Convert an hexadecimal representation of an EDID to a raw representation.
-   * 
-   * @param   edid  The EDID in hexadecimal representation.
-   * @return        The EDID in raw representation, it will be half the length
-   *                of `edid` (the input value).
-   */
-  unsigned char* unhex_edid(const std::string edid)
-  {
-    const char* cstr = edid.c_str();
-    return libgamma_unhex_edid(cstr);
-  }
-  
-  
-  /**
-   * Initialise a gamma ramp in the proper way that allows all adjustment
-   * methods to read from and write to it without causing segmentation violation.
-   * 
-   * @param  ramps  The gamma ramp to initialise.
-   * @param  red    The size of the gamma ramp for the red channel.
-   * @param  green  The size of the gamma ramp for the green channel.
-   * @param  blue   The size of the gamma ramp for the blue channel.
-   */
-  void gamma_ramps8_initialise(GammaRamps<uint8_t>* ramps, size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps8_t native;
-    int r;
-    native.red_size   = ramps->red.size   = red;
-    native.green_size = ramps->green.size = green;
-    native.blue_size  = ramps->blue.size  = blue;
-    ramps->depth = 8;
-    r = libgamma_gamma_ramps8_initialise(&native);
-    if (r != 0)
-      throw create_error(r);
-    ramps->red.ramp   = native.red;
-    ramps->green.ramp = native.green;
-    ramps->blue.ramp  = native.blue;
-  }
-  
-  /**
-   * Initialise a gamma ramp in the proper way that allows all adjustment
-   * methods to read from and write to it without causing segmentation violation.
-   * 
-   * @param  ramps  The gamma ramp to initialise.
-   * @param  red    The size of the gamma ramp for the red channel.
-   * @param  green  The size of the gamma ramp for the green channel.
-   * @param  blue   The size of the gamma ramp for the blue channel.
-   */
-  void gamma_ramps16_initialise(GammaRamps<uint16_t>* ramps, size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps16_t native;
-    int r;
-    native.red_size   = ramps->red.size   = red;
-    native.green_size = ramps->green.size = green;
-    native.blue_size  = ramps->blue.size  = blue;
-    ramps->depth = 16;
-    r = libgamma_gamma_ramps16_initialise(&native);
-    if (r != 0)
-      throw create_error(r);
-    ramps->red.ramp   = native.red;
-    ramps->green.ramp = native.green;
-    ramps->blue.ramp  = native.blue;
-  }
-  
-  /**
-   * Initialise a gamma ramp in the proper way that allows all adjustment
-   * methods to read from and write to it without causing segmentation violation.
-   * 
-   * @param  ramps  The gamma ramp to initialise.
-   * @param  red    The size of the gamma ramp for the red channel.
-   * @param  green  The size of the gamma ramp for the green channel.
-   * @param  blue   The size of the gamma ramp for the blue channel.
-   */
-  void gamma_ramps32_initialise(GammaRamps<uint32_t>* ramps, size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps32_t native;
-    int r;
-    native.red_size   = ramps->red.size   = red;
-    native.green_size = ramps->green.size = green;
-    native.blue_size  = ramps->blue.size  = blue;
-    ramps->depth = 32;
-    r = libgamma_gamma_ramps32_initialise(&native);
-    if (r != 0)
-      throw create_error(r);
-    ramps->red.ramp   = native.red;
-    ramps->green.ramp = native.green;
-    ramps->blue.ramp  = native.blue;
-  }
-  
-  /**
-   * Initialise a gamma ramp in the proper way that allows all adjustment
-   * methods to read from and write to it without causing segmentation violation.
-   * 
-   * @param  ramps  The gamma ramp to initialise.
-   * @param  red    The size of the gamma ramp for the red channel.
-   * @param  green  The size of the gamma ramp for the green channel.
-   * @param  blue   The size of the gamma ramp for the blue channel.
-   */
-  void gamma_ramps64_initialise(GammaRamps<uint64_t>* ramps, size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps64_t native;
-    int r;
-    native.red_size   = ramps->red.size   = red;
-    native.green_size = ramps->green.size = green;
-    native.blue_size  = ramps->blue.size  = blue;
-    ramps->depth = 64;
-    r = libgamma_gamma_ramps64_initialise(&native);
-    if (r != 0)
-      throw create_error(r);
-    ramps->red.ramp   = native.red;
-    ramps->green.ramp = native.green;
-    ramps->blue.ramp  = native.blue;
-  }
-  
-  /**
-   * Initialise a gamma ramp in the proper way that allows all adjustment
-   * methods to read from and write to it without causing segmentation violation.
-   * 
-   * @param  ramps  The gamma ramp to initialise.
-   * @param  red    The size of the gamma ramp for the red channel.
-   * @param  green  The size of the gamma ramp for the green channel.
-   * @param  blue   The size of the gamma ramp for the blue channel.
-   */
-  void gamma_rampsf_initialise(GammaRamps<float>* ramps, size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_rampsf_t native;
-    int r;
-    native.red_size   = ramps->red.size   = red;
-    native.green_size = ramps->green.size = green;
-    native.blue_size  = ramps->blue.size  = blue;
-    ramps->depth = -1;
-    r = libgamma_gamma_rampsf_initialise(&native);
-    if (r != 0)
-      throw create_error(r);
-    ramps->red.ramp   = native.red;
-    ramps->green.ramp = native.green;
-    ramps->blue.ramp  = native.blue;
-  }
-  
-  /**
-   * Initialise a gamma ramp in the proper way that allows all adjustment
-   * methods to read from and write to it without causing segmentation violation.
-   * 
-   * @param  ramps  The gamma ramp to initialise.
-   * @param  red    The size of the gamma ramp for the red channel.
-   * @param  green  The size of the gamma ramp for the green channel.
-   * @param  blue   The size of the gamma ramp for the blue channel.
-   */
-  void gamma_rampsd_initialise(GammaRamps<double>* ramps, size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_rampsd_t native;
-    int r;
-    native.red_size   = ramps->red.size   = red;
-    native.green_size = ramps->green.size = green;
-    native.blue_size  = ramps->blue.size  = blue;
-    ramps->depth = -2;
-    r = libgamma_gamma_rampsd_initialise(&native);
-    if (r != 0)
-      throw create_error(r);
-    ramps->red.ramp   = native.red;
-    ramps->green.ramp = native.green;
-    ramps->blue.ramp  = native.blue;
-  }
-  
-  
-  /**
-   * 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    The size of the gamma ramp for the red channel.
-   * @param   green  The size of the gamma ramp for the green channel.
-   * @param   blue   The size of the gamma ramp for the blue channel.
-   * @return         The gamma ramp.
-   */
-  GammaRamps<uint8_t>* gamma_ramps8_create(size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps8_t ramps;
-    int r;
-    ramps.red_size = red;
-    ramps.green_size = green;
-    ramps.blue_size = blue;
-    r = libgamma_gamma_ramps8_initialise(&ramps);
-    if (r != 0)
-      throw create_error(r);
-    return new GammaRamps<uint8_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 8);
-  }
-  
-  /**
-   * 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    The size of the gamma ramp for the red channel.
-   * @param   green  The size of the gamma ramp for the green channel.
-   * @param   blue   The size of the gamma ramp for the blue channel.
-   * @return         The gamma ramp.
-   */
-  GammaRamps<uint16_t>* gamma_ramps16_create(size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps16_t ramps;
-    int r;
-    ramps.red_size = red;
-    ramps.green_size = green;
-    ramps.blue_size = blue;
-    r = libgamma_gamma_ramps16_initialise(&ramps);
-    if (r != 0)
-      throw create_error(r);
-    return new GammaRamps<uint16_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 16);
-  }
-  
-  /**
-   * 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    The size of the gamma ramp for the red channel.
-   * @param   green  The size of the gamma ramp for the green channel.
-   * @param   blue   The size of the gamma ramp for the blue channel.
-   * @return         The gamma ramp.
-   */
-  GammaRamps<uint32_t>* gamma_ramps32_create(size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps32_t ramps;
-    int r;
-    ramps.red_size = red;
-    ramps.green_size = green;
-    ramps.blue_size = blue;
-    r = libgamma_gamma_ramps32_initialise(&ramps);
-    if (r != 0)
-      throw create_error(r);
-    return new GammaRamps<uint32_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 32);
-  }
-  
-  /**
-   * 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    The size of the gamma ramp for the red channel.
-   * @param   green  The size of the gamma ramp for the green channel.
-   * @param   blue   The size of the gamma ramp for the blue channel.
-   * @return         The gamma ramp.
-   */
-  GammaRamps<uint64_t>* gamma_ramps64_create(size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_ramps64_t ramps;
-    int r;
-    ramps.red_size = red;
-    ramps.green_size = green;
-    ramps.blue_size = blue;
-    r = libgamma_gamma_ramps64_initialise(&ramps);
-    if (r != 0)
-      throw create_error(r);
-    return new GammaRamps<uint64_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 64);
-  }
-  
-  /**
-   * 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    The size of the gamma ramp for the red channel.
-   * @param   green  The size of the gamma ramp for the green channel.
-   * @param   blue   The size of the gamma ramp for the blue channel.
-   * @return         The gamma ramp.
-   */
-  GammaRamps<float>* gamma_rampsf_create(size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_rampsf_t ramps;
-    int r;
-    ramps.red_size = red;
-    ramps.green_size = green;
-    ramps.blue_size = blue;
-    r = libgamma_gamma_rampsf_initialise(&ramps);
-    if (r != 0)
-      throw create_error(r);
-    return new GammaRamps<float>(ramps.red, ramps.green, ramps.blue, red, green, blue, -1);
-  }
-  
-  /**
-   * 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    The size of the gamma ramp for the red channel.
-   * @param   green  The size of the gamma ramp for the green channel.
-   * @param   blue   The size of the gamma ramp for the blue channel.
-   * @return         The gamma ramp.
-   */
-  GammaRamps<double>* gamma_rampsd_create(size_t red, size_t blue, size_t green)
-  {
-    libgamma_gamma_rampsd_t ramps;
-    int r;
-    ramps.red_size = red;
-    ramps.green_size = green;
-    ramps.blue_size = blue;
-    r = libgamma_gamma_rampsd_initialise(&ramps);
-    if (r != 0)
-      throw create_error(r);
-    return new GammaRamps<double>(ramps.red, ramps.green, ramps.blue, red, green, blue, -2);
-  }
-  
-}
+	/**
+	 * List available adjustment methods by their order of preference based on the environment
+	 * 
+	 * @param  operation  Allowed values
+	 *                      0: Methods that the environment suggests will work, excluding fake
+	 *                      1: Methods that the environment suggests will work, including fake
+	 *                      2: All real non-fake methods
+	 *                      3: All real methods
+	 *                      4: All methods
+	 *                    Other values invoke undefined behaviour
+	 * @return            Array of methods
+	 */
+	std::vector<int>
+	list_methods(int operation)
+	{
+		int *methods = (int*)malloc(LIBGAMMA_METHOD_COUNT * sizeof(int));
+		size_t n, i;
+		std::vector<int> rc;
+
+		n = libgamma_list_methods(methods, LIBGAMMA_METHOD_COUNT, operation);
+		if (n > LIBGAMMA_METHOD_COUNT) {
+			free(methods);
+			methods = (int*)malloc(n * sizeof(int));
+			libgamma_list_methods(methods, n, operation);
+		}
+
+		for (i = 0; i < n; i++)
+			rc.push_back(methods[i]);
+
+		free(methods);
+		return rc;
+	}
+
+	/**
+	 * Check whether an adjustment method is available, non-existing (invalid) methods will be
+	 * identified as not available under the rationale that the library may be out of date
+	 * 
+	 * @param   method  The adjustment method
+	 * @return          Whether the adjustment method is available
+	 */
+	int
+	is_method_available(int method)
+	{
+		return libgamma_is_method_available(method);
+	}
+
+	/**
+	 * Return the capabilities of an adjustment method
+	 * 
+	 * @param  output  The data structure to fill with the method's capabilities
+	 * @param  method  The adjustment method (display server and protocol)
+	 */
+	void
+	method_capabilities(MethodCapabilities *output, int method)
+	{
+		libgamma_method_capabilities_t caps;
+		libgamma_method_capabilities(&caps, method);
+		*output = MethodCapabilities(&caps);
+	}
+
+	/**
+	 * Return the default site for an adjustment method
+	 * 
+	 * @param   method  The adjustment method (display server and protocol)
+	 * @return          The default site, `nullptr` if it cannot be determined or if
+	 *                  multiple sites are not supported by the adjustment method
+	 */
+	std::string *
+	method_default_site(int method)
+	{
+		char *cstr = libgamma_method_default_site(method);
+		if (cstr == nullptr)
+			return nullptr;
+		return new std::string(cstr);
+	}
+
+	/**
+	 * Return the default variable that determines
+	 * the default site for an adjustment method
+	 * 
+	 * @param   method  The adjustment method (display server and protocol)
+	 * @return          The environ variables that is used to determine the
+	 *                  default site. `nullptr` if there is none, that is, if
+	 *                  the method does not support multiple sites.
+	 *                  This value should not be `free`:d.
+	 */
+	std::string *
+	method_default_site_variable(int method)
+	{
+		const char *cstr = libgamma_method_default_site_variable(method);
+		if (cstr == nullptr)
+			return nullptr;
+		return new std::string(cstr);
+	}
+
+	/**
+	 * Convert a raw representation of an EDID to a lowercase hexadecimal representation
+	 * 
+	 * @param   edid    The EDID in raw representation
+	 * @param   length  The length of `edid`
+	 * @return          The EDID in lowercase hexadecimal representation
+	 */
+	std::string
+	behex_edid(const unsigned char *edid, size_t length)
+	{
+		return behex_edid_lowercase(edid, length);
+	}
+
+	/**
+	 * Convert a raw representation of an EDID to a lowercase hexadecimal representation
+	 * 
+	 * @param   edid    The EDID in raw representation
+	 * @param   length  The length of `edid`
+	 * @return          The EDID in lowercase hexadecimal representation
+	 */
+	std::string
+	behex_edid_lowercase(const unsigned char *edid, size_t length)
+	{
+		char *cstr = libgamma_behex_edid_lowercase(edid, length);
+		std::string rc = std::string(cstr);
+		free(cstr);
+		return rc;
+	}
+
+	/**
+	 * Convert a raw representation of an EDID to an uppercase hexadecimal representation
+	 * 
+	 * @param   edid    The EDID in raw representation
+	 * @param   length  The length of `edid`
+	 * @return          The EDID in uppercase hexadecimal representation
+	 */
+	std::string
+	behex_edid_uppercase(const unsigned char *edid, size_t length)
+	{
+		char *cstr = libgamma_behex_edid_uppercase(edid, length);
+		std::string rc = std::string(cstr);
+		free(cstr);
+		return rc;
+	}
 
+	/**
+	 * Convert an hexadecimal representation of an EDID to a raw representation
+	 * 
+	 * @param   edid  The EDID in hexadecimal representation
+	 * @return        The EDID in raw representation, it will be half the length
+	 *                of `edid` (the input value)
+	 */
+	unsigned char *
+	unhex_edid(const std::string edid)
+	{
+		const char *cstr = edid.c_str();
+		return libgamma_unhex_edid(cstr);
+	}
+
+	/**
+	 * Initialise a gamma ramp in the proper way that allows all adjustment
+	 * methods to read from and write to it without causing segmentation violation
+	 * 
+	 * @param  ramps  The gamma ramp to initialise
+	 * @param  red    The size of the gamma ramp for the red channel
+	 * @param  green  The size of the gamma ramp for the green channel
+	 * @param  blue   The size of the gamma ramp for the blue channel
+	 */
+	void
+	gamma_ramps8_initialise(GammaRamps<uint8_t> *ramps, size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps8_t native;
+		int r;
+		native.red_size   = ramps->red.size   = red;
+		native.green_size = ramps->green.size = green;
+		native.blue_size  = ramps->blue.size  = blue;
+		ramps->depth = 8;
+		r = libgamma_gamma_ramps8_initialise(&native);
+		if (r)
+			throw create_error(r);
+		ramps->red.ramp   = native.red;
+		ramps->green.ramp = native.green;
+		ramps->blue.ramp  = native.blue;
+	}
+
+	/**
+	 * Initialise a gamma ramp in the proper way that allows all adjustment
+	 * methods to read from and write to it without causing segmentation violation
+	 * 
+	 * @param  ramps  The gamma ramp to initialise
+	 * @param  red    The size of the gamma ramp for the red channel
+	 * @param  green  The size of the gamma ramp for the green channel
+	 * @param  blue   The size of the gamma ramp for the blue channel
+	 */
+	void
+	gamma_ramps16_initialise(GammaRamps<uint16_t> *ramps, size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps16_t native;
+		int r;
+		native.red_size   = ramps->red.size   = red;
+		native.green_size = ramps->green.size = green;
+		native.blue_size  = ramps->blue.size  = blue;
+		ramps->depth = 16;
+		r = libgamma_gamma_ramps16_initialise(&native);
+		if (r)
+			throw create_error(r);
+		ramps->red.ramp   = native.red;
+		ramps->green.ramp = native.green;
+		ramps->blue.ramp  = native.blue;
+	}
+
+	/**
+	 * Initialise a gamma ramp in the proper way that allows all adjustment
+	 * methods to read from and write to it without causing segmentation violation
+	 * 
+	 * @param  ramps  The gamma ramp to initialise
+	 * @param  red    The size of the gamma ramp for the red channel
+	 * @param  green  The size of the gamma ramp for the green channel
+	 * @param  blue   The size of the gamma ramp for the blue channel
+	 */
+	void
+	gamma_ramps32_initialise(GammaRamps<uint32_t> *ramps, size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps32_t native;
+		int r;
+		native.red_size   = ramps->red.size   = red;
+		native.green_size = ramps->green.size = green;
+		native.blue_size  = ramps->blue.size  = blue;
+		ramps->depth = 32;
+		r = libgamma_gamma_ramps32_initialise(&native);
+		if (r)
+			throw create_error(r);
+		ramps->red.ramp   = native.red;
+		ramps->green.ramp = native.green;
+		ramps->blue.ramp  = native.blue;
+	}
+
+	/**
+	 * Initialise a gamma ramp in the proper way that allows all adjustment
+	 * methods to read from and write to it without causing segmentation violation
+	 * 
+	 * @param  ramps  The gamma ramp to initialise
+	 * @param  red    The size of the gamma ramp for the red channel
+	 * @param  green  The size of the gamma ramp for the green channel
+	 * @param  blue   The size of the gamma ramp for the blue channel
+	 */
+	void
+	gamma_ramps64_initialise(GammaRamps<uint64_t> *ramps, size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps64_t native;
+		int r;
+		native.red_size   = ramps->red.size   = red;
+		native.green_size = ramps->green.size = green;
+		native.blue_size  = ramps->blue.size  = blue;
+		ramps->depth = 64;
+		r = libgamma_gamma_ramps64_initialise(&native);
+		if (r)
+			throw create_error(r);
+		ramps->red.ramp   = native.red;
+		ramps->green.ramp = native.green;
+		ramps->blue.ramp  = native.blue;
+	}
+
+	/**
+	 * Initialise a gamma ramp in the proper way that allows all adjustment
+	 * methods to read from and write to it without causing segmentation violation.
+	 * 
+	 * @param  ramps  The gamma ramp to initialise.
+	 * @param  red    The size of the gamma ramp for the red channel.
+	 * @param  green  The size of the gamma ramp for the green channel.
+	 * @param  blue   The size of the gamma ramp for the blue channel.
+	 */
+	void
+	gamma_rampsf_initialise(GammaRamps<float> *ramps, size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_rampsf_t native;
+		int r;
+		native.red_size   = ramps->red.size   = red;
+		native.green_size = ramps->green.size = green;
+		native.blue_size  = ramps->blue.size  = blue;
+		ramps->depth = -1;
+		r = libgamma_gamma_rampsf_initialise(&native);
+		if (r)
+			throw create_error(r);
+		ramps->red.ramp   = native.red;
+		ramps->green.ramp = native.green;
+		ramps->blue.ramp  = native.blue;
+	}
+
+	/**
+	 * Initialise a gamma ramp in the proper way that allows all adjustment
+	 * methods to read from and write to it without causing segmentation violation
+	 * 
+	 * @param  ramps  The gamma ramp to initialise
+	 * @param  red    The size of the gamma ramp for the red channel
+	 * @param  green  The size of the gamma ramp for the green channel
+	 * @param  blue   The size of the gamma ramp for the blue channel
+	 */
+	void
+	gamma_rampsd_initialise(GammaRamps<double> *ramps, size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_rampsd_t native;
+		int r;
+		native.red_size   = ramps->red.size   = red;
+		native.green_size = ramps->green.size = green;
+		native.blue_size  = ramps->blue.size  = blue;
+		ramps->depth = -2;
+		r = libgamma_gamma_rampsd_initialise(&native);
+		if (r)
+			throw create_error(r);
+		ramps->red.ramp   = native.red;
+		ramps->green.ramp = native.green;
+		ramps->blue.ramp  = native.blue;
+	}
+
+	/**
+	 * 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    The size of the gamma ramp for the red channel
+	 * @param   green  The size of the gamma ramp for the green channel
+	 * @param   blue   The size of the gamma ramp for the blue channel
+	 * @return         The gamma ramp
+	 */
+	GammaRamps<uint8_t> *
+	gamma_ramps8_create(size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps8_t ramps;
+		int r;
+		ramps.red_size = red;
+		ramps.green_size = green;
+		ramps.blue_size = blue;
+		r = libgamma_gamma_ramps8_initialise(&ramps);
+		if (r)
+			throw create_error(r);
+		return new GammaRamps<uint8_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 8);
+	}
+
+	/**
+	 * 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    The size of the gamma ramp for the red channel
+	 * @param   green  The size of the gamma ramp for the green channel
+	 * @param   blue   The size of the gamma ramp for the blue channel
+	 * @return         The gamma ramp
+	 */
+	GammaRamps<uint16_t> *
+	gamma_ramps16_create(size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps16_t ramps;
+		int r;
+		ramps.red_size = red;
+		ramps.green_size = green;
+		ramps.blue_size = blue;
+		r = libgamma_gamma_ramps16_initialise(&ramps);
+		if (r)
+			throw create_error(r);
+		return new GammaRamps<uint16_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 16);
+	}
+
+	/**
+	 * 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    The size of the gamma ramp for the red channel
+	 * @param   green  The size of the gamma ramp for the green channel
+	 * @param   blue   The size of the gamma ramp for the blue channel
+	 * @return         The gamma ramp
+	 */
+	GammaRamps<uint32_t> *
+	gamma_ramps32_create(size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps32_t ramps;
+		int r;
+		ramps.red_size = red;
+		ramps.green_size = green;
+		ramps.blue_size = blue;
+		r = libgamma_gamma_ramps32_initialise(&ramps);
+		if (r)
+			throw create_error(r);
+		return new GammaRamps<uint32_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 32);
+	}
+
+	/**
+	 * 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    The size of the gamma ramp for the red channel
+	 * @param   green  The size of the gamma ramp for the green channel
+	 * @param   blue   The size of the gamma ramp for the blue channel
+	 * @return         The gamma ramp
+	 */
+	GammaRamps<uint64_t> *
+	gamma_ramps64_create(size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_ramps64_t ramps;
+		int r;
+		ramps.red_size = red;
+		ramps.green_size = green;
+		ramps.blue_size = blue;
+		r = libgamma_gamma_ramps64_initialise(&ramps);
+		if (r)
+			throw create_error(r);
+		return new GammaRamps<uint64_t>(ramps.red, ramps.green, ramps.blue, red, green, blue, 64);
+	}
+
+	/**
+	 * 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    The size of the gamma ramp for the red channel.
+	 * @param   green  The size of the gamma ramp for the green channel.
+	 * @param   blue   The size of the gamma ramp for the blue channel.
+	 * @return         The gamma ramp.
+	 */
+	GammaRamps<float> *
+	gamma_rampsf_create(size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_rampsf_t ramps;
+		int r;
+		ramps.red_size = red;
+		ramps.green_size = green;
+		ramps.blue_size = blue;
+		r = libgamma_gamma_rampsf_initialise(&ramps);
+		if (r)
+			throw create_error(r);
+		return new GammaRamps<float>(ramps.red, ramps.green, ramps.blue, red, green, blue, -1);
+	}
+
+	/**
+	 * 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    The size of the gamma ramp for the red channel.
+	 * @param   green  The size of the gamma ramp for the green channel.
+	 * @param   blue   The size of the gamma ramp for the blue channel.
+	 * @return         The gamma ramp.
+	 */
+	GammaRamps<double> *
+	gamma_rampsd_create(size_t red, size_t blue, size_t green)
+	{
+		libgamma_gamma_rampsd_t ramps;
+		int r;
+		ramps.red_size = red;
+		ramps.green_size = green;
+		ramps.blue_size = blue;
+		r = libgamma_gamma_rampsd_initialise(&ramps);
+		if (r)
+			throw create_error(r);
+		return new GammaRamps<double>(ramps.red, ramps.green, ramps.blue, red, green, blue, -2);
+	}
+}