From 3c57dd931145d43f2b0aef96c4d178135956bf91 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 05:13:10 +0200 Subject: Adding upstream version 2.10.36. Signed-off-by: Daniel Baumann --- libgimpconfig/gimpcolorconfig.c | 1087 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 1087 insertions(+) create mode 100644 libgimpconfig/gimpcolorconfig.c (limited to 'libgimpconfig/gimpcolorconfig.c') diff --git a/libgimpconfig/gimpcolorconfig.c b/libgimpconfig/gimpcolorconfig.c new file mode 100644 index 0000000..ccb8476 --- /dev/null +++ b/libgimpconfig/gimpcolorconfig.c @@ -0,0 +1,1087 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * GimpColorConfig class + * Copyright (C) 2004 Stefan Döhla + * + * This library is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * . + */ + +#include "config.h" + +#include +#include +#include + +#include "libgimpbase/gimpbase.h" +#include "libgimpcolor/gimpcolor.h" + +#include "gimpconfigtypes.h" + +#include "gimpcolorconfig.h" +#include "gimpconfig-error.h" +#include "gimpconfig-iface.h" +#include "gimpconfig-params.h" +#include "gimpconfig-path.h" + +#include "libgimp/libgimp-intl.h" + + +/** + * SECTION: gimpcolorconfig + * @title: GimpColorConfig + * @short_description: Color management settings. + * + * Color management settings. + **/ + + +#define COLOR_MANAGEMENT_MODE_BLURB \ + _("How images are displayed on screen.") + +#define DISPLAY_PROFILE_BLURB \ + _("The color profile of your (primary) monitor.") + +#define DISPLAY_PROFILE_FROM_GDK_BLURB \ + _("When enabled, GIMP will try to use the display color profile from " \ + "the windowing system. The configured monitor profile is then only " \ + "used as a fallback.") + +#define RGB_PROFILE_BLURB \ + _("The preferred RGB working space color profile. It will be offered " \ + "next to the built-in RGB profile when a color profile can be chosen.") + +#define GRAY_PROFILE_BLURB \ + _("The preferred grayscale working space color profile. It will be offered " \ + "next to the built-in grayscale profile when a color profile can be chosen.") + +#define CMYK_PROFILE_BLURB \ + _("The CMYK color profile used to convert between RGB and CMYK.") + +#define SIMULATION_PROFILE_BLURB \ + _("The color profile to use for soft-proofing from your image's " \ + "color space to some other color space, including " \ + "soft-proofing to a printer or other output device profile. ") + +#define DISPLAY_RENDERING_INTENT_BLURB \ + _("How colors are converted from your image's color space to your " \ + "display device. Relative colorimetric is usually the best choice. " \ + "Unless you use a LUT monitor profile (most monitor profiles are " \ + "matrix), choosing perceptual intent really gives you relative " \ + "colorimetric." ) + +#define DISPLAY_USE_BPC_BLURB \ + _("Do use black point compensation (unless you know you have a reason " \ + "not to).") + +#define DISPLAY_OPTIMIZE_BLURB \ + _("When disabled, image display might be of better quality " \ + "at the cost of speed.") + +#define SIMULATION_RENDERING_INTENT_BLURB \ + _("How colors are converted from your image's color space to the " \ + "output simulation device (usually your monitor). " \ + "Try them all and choose what looks the best. ") + +#define SIMULATION_USE_BPC_BLURB \ + _("Try with and without black point compensation "\ + "and choose what looks best. ") + +#define SIMULATION_OPTIMIZE_BLURB \ + _("When disabled, soft-proofing might be of better quality " \ + "at the cost of speed.") + +#define SIMULATION_GAMUT_CHECK_BLURB \ + _("When enabled, the soft-proofing will mark colors " \ + "which can not be represented in the target color space.") + +#define OUT_OF_GAMUT_COLOR_BLURB \ + _("The color to use for marking colors which are out of gamut.") + +#define SHOW_RGB_U8_BLURB \ + _("When enabled, set the color scales to display 0...255 instead " \ + "of percentages") + +#define SHOW_HSV_BLURB \ + _("When enabled, set the color scales to display HSV blend mode instead " \ + "of LCh") + +enum +{ + PROP_0, + PROP_MODE, + PROP_RGB_PROFILE, + PROP_GRAY_PROFILE, + PROP_CMYK_PROFILE, + PROP_DISPLAY_PROFILE, + PROP_DISPLAY_PROFILE_FROM_GDK, + PROP_SIMULATION_PROFILE, + PROP_DISPLAY_RENDERING_INTENT, + PROP_DISPLAY_USE_BPC, + PROP_DISPLAY_OPTIMIZE, + PROP_SIMULATION_RENDERING_INTENT, + PROP_SIMULATION_USE_BPC, + PROP_SIMULATION_OPTIMIZE, + PROP_SIMULATION_GAMUT_CHECK, + PROP_OUT_OF_GAMUT_COLOR, + PROP_SHOW_RGB_U8, + PROP_SHOW_HSV, + PROP_DISPLAY_MODULE +}; + + +typedef struct _GimpColorConfigPrivate GimpColorConfigPrivate; + +struct _GimpColorConfigPrivate +{ + gboolean display_optimize; + gboolean simulation_optimize; + + gboolean show_rgb_u8; + gboolean show_hsv; +}; + +#define GET_PRIVATE(obj) \ + ((GimpColorConfigPrivate *) gimp_color_config_get_instance_private ((GimpColorConfig *) (obj))) + + +static void gimp_color_config_finalize (GObject *object); +static void gimp_color_config_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_color_config_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + +static void gimp_color_config_set_rgb_profile (GimpColorConfig *config, + const gchar *filename, + GError **error); +static void gimp_color_config_set_gray_profile (GimpColorConfig *config, + const gchar *filename, + GError **error); +static void gimp_color_config_set_cmyk_profile (GimpColorConfig *config, + const gchar *filename, + GError **error); +static void gimp_color_config_set_display_profile (GimpColorConfig *config, + const gchar *filename, + GError **error); +static void gimp_color_config_set_simulation_profile (GimpColorConfig *config, + const gchar *filename, + GError **error); + + +G_DEFINE_TYPE_WITH_CODE (GimpColorConfig, gimp_color_config, G_TYPE_OBJECT, + G_ADD_PRIVATE (GimpColorConfig) + G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONFIG, NULL) + gimp_type_set_translation_domain (g_define_type_id, + GETTEXT_PACKAGE "-libgimp")) + +#define parent_class gimp_color_config_parent_class + + +static void +gimp_color_config_class_init (GimpColorConfigClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpRGB color; + + gimp_rgba_set (&color, 1.0, 0.0, 1.0, 1.0); /* magenta */ + + object_class->finalize = gimp_color_config_finalize; + object_class->set_property = gimp_color_config_set_property; + object_class->get_property = gimp_color_config_get_property; + + GIMP_CONFIG_PROP_ENUM (object_class, PROP_MODE, + "mode", + _("Mode of operation"), + COLOR_MANAGEMENT_MODE_BLURB, + GIMP_TYPE_COLOR_MANAGEMENT_MODE, + GIMP_COLOR_MANAGEMENT_DISPLAY, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_PATH (object_class, PROP_RGB_PROFILE, + "rgb-profile", + _("Preferred RGB profile"), + RGB_PROFILE_BLURB, + GIMP_CONFIG_PATH_FILE, NULL, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_PATH (object_class, PROP_GRAY_PROFILE, + "gray-profile", + _("Preferred grayscale profile"), + GRAY_PROFILE_BLURB, + GIMP_CONFIG_PATH_FILE, NULL, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_PATH (object_class, PROP_CMYK_PROFILE, + "cmyk-profile", + _("CMYK profile"), + CMYK_PROFILE_BLURB, + GIMP_CONFIG_PATH_FILE, NULL, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_PATH (object_class, PROP_DISPLAY_PROFILE, + "display-profile", + _("Monitor profile"), + DISPLAY_PROFILE_BLURB, + GIMP_CONFIG_PATH_FILE, NULL, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DISPLAY_PROFILE_FROM_GDK, + "display-profile-from-gdk", + _("Use the system monitor profile"), + DISPLAY_PROFILE_FROM_GDK_BLURB, + FALSE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_PATH (object_class, PROP_SIMULATION_PROFILE, + /* FIXME: 3.0: change to simulation-profile */ + "printer-profile", + _("Simulation profile for soft-proofing"), + SIMULATION_PROFILE_BLURB, + GIMP_CONFIG_PATH_FILE, NULL, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_ENUM (object_class, PROP_DISPLAY_RENDERING_INTENT, + "display-rendering-intent", + _("Display rendering intent"), + DISPLAY_RENDERING_INTENT_BLURB, + GIMP_TYPE_COLOR_RENDERING_INTENT, + GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DISPLAY_USE_BPC, + "display-use-black-point-compensation", + _("Use black point compensation for the display"), + DISPLAY_USE_BPC_BLURB, + TRUE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_DISPLAY_OPTIMIZE, + "display-optimize", + _("Optimize display color transformations"), + DISPLAY_OPTIMIZE_BLURB, + TRUE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_ENUM (object_class, PROP_SIMULATION_RENDERING_INTENT, + "simulation-rendering-intent", + _("Soft-proofing rendering intent"), + SIMULATION_RENDERING_INTENT_BLURB, + GIMP_TYPE_COLOR_RENDERING_INTENT, + GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SIMULATION_USE_BPC, + "simulation-use-black-point-compensation", + _("Use black point compensation for soft-proofing"), + SIMULATION_USE_BPC_BLURB, + FALSE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SIMULATION_OPTIMIZE, + "simulation-optimize", + _("Optimize soft-proofing color transformations"), + SIMULATION_OPTIMIZE_BLURB, + TRUE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SIMULATION_GAMUT_CHECK, + "simulation-gamut-check", + _("Mark out of gamut colors"), + SIMULATION_GAMUT_CHECK_BLURB, + FALSE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_RGB (object_class, PROP_OUT_OF_GAMUT_COLOR, + "out-of-gamut-color", + _("Out of gamut warning color"), + OUT_OF_GAMUT_COLOR_BLURB, + FALSE, &color, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SHOW_RGB_U8, + "show-rgb-u8", + "Show RGB 0..255", + _("Show RGB 0..255 scales"), + FALSE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_BOOLEAN (object_class, PROP_SHOW_HSV, + "show-hsv", + "Show HSV", + _("Show HSV instead of LCH"), + FALSE, + GIMP_PARAM_STATIC_STRINGS); + + GIMP_CONFIG_PROP_STRING (object_class, PROP_DISPLAY_MODULE, + "display-module", + "Display module", + "This property is deprecated and its value ignored", + "CdisplayLcms", + GIMP_PARAM_STATIC_STRINGS); +} + +static void +gimp_color_config_init (GimpColorConfig *config) +{ +} + +static void +gimp_color_config_finalize (GObject *object) +{ + GimpColorConfig *color_config = GIMP_COLOR_CONFIG (object); + + if (color_config->rgb_profile) + g_free (color_config->rgb_profile); + + if (color_config->gray_profile) + g_free (color_config->gray_profile); + + if (color_config->cmyk_profile) + g_free (color_config->cmyk_profile); + + if (color_config->display_profile) + g_free (color_config->display_profile); + + if (color_config->printer_profile) + g_free (color_config->printer_profile); + + if (color_config->display_module) + g_free (color_config->display_module); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_color_config_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpColorConfig *color_config = GIMP_COLOR_CONFIG (object); + GimpColorConfigPrivate *priv = GET_PRIVATE (object); + GError *error = NULL; + + switch (property_id) + { + case PROP_MODE: + color_config->mode = g_value_get_enum (value); + break; + case PROP_RGB_PROFILE: + gimp_color_config_set_rgb_profile (color_config, + g_value_get_string (value), + &error); + break; + case PROP_GRAY_PROFILE: + gimp_color_config_set_gray_profile (color_config, + g_value_get_string (value), + &error); + break; + case PROP_CMYK_PROFILE: + gimp_color_config_set_cmyk_profile (color_config, + g_value_get_string (value), + &error); + break; + case PROP_DISPLAY_PROFILE: + gimp_color_config_set_display_profile (color_config, + g_value_get_string (value), + &error); + break; + case PROP_DISPLAY_PROFILE_FROM_GDK: + color_config->display_profile_from_gdk = g_value_get_boolean (value); + break; + case PROP_SIMULATION_PROFILE: + gimp_color_config_set_simulation_profile (color_config, + g_value_get_string (value), + &error); + break; + case PROP_DISPLAY_RENDERING_INTENT: + color_config->display_intent = g_value_get_enum (value); + break; + case PROP_DISPLAY_USE_BPC: + color_config->display_use_black_point_compensation = g_value_get_boolean (value); + break; + case PROP_DISPLAY_OPTIMIZE: + priv->display_optimize = g_value_get_boolean (value); + break; + case PROP_SIMULATION_RENDERING_INTENT: + color_config->simulation_intent = g_value_get_enum (value); + break; + case PROP_SIMULATION_USE_BPC: + color_config->simulation_use_black_point_compensation = g_value_get_boolean (value); + break; + case PROP_SIMULATION_OPTIMIZE: + priv->simulation_optimize = g_value_get_boolean (value); + break; + case PROP_SIMULATION_GAMUT_CHECK: + color_config->simulation_gamut_check = g_value_get_boolean (value); + break; + case PROP_OUT_OF_GAMUT_COLOR: + color_config->out_of_gamut_color = *(GimpRGB *) g_value_get_boxed (value); + break; + case PROP_SHOW_RGB_U8: + priv->show_rgb_u8 = g_value_get_boolean (value); + break; + case PROP_SHOW_HSV: + priv->show_hsv = g_value_get_boolean (value); + break; + case PROP_DISPLAY_MODULE: + g_free (color_config->display_module); + color_config->display_module = g_value_dup_string (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } + + if (error) + { + g_message ("%s", error->message); + g_clear_error (&error); + } +} + +static void +gimp_color_config_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpColorConfig *color_config = GIMP_COLOR_CONFIG (object); + GimpColorConfigPrivate *priv = GET_PRIVATE (object); + + switch (property_id) + { + case PROP_MODE: + g_value_set_enum (value, color_config->mode); + break; + case PROP_RGB_PROFILE: + g_value_set_string (value, color_config->rgb_profile); + break; + case PROP_GRAY_PROFILE: + g_value_set_string (value, color_config->gray_profile); + break; + case PROP_CMYK_PROFILE: + g_value_set_string (value, color_config->cmyk_profile); + break; + case PROP_DISPLAY_PROFILE: + g_value_set_string (value, color_config->display_profile); + break; + case PROP_DISPLAY_PROFILE_FROM_GDK: + g_value_set_boolean (value, color_config->display_profile_from_gdk); + break; + case PROP_SIMULATION_PROFILE: + g_value_set_string (value, color_config->printer_profile); + break; + case PROP_DISPLAY_RENDERING_INTENT: + g_value_set_enum (value, color_config->display_intent); + break; + case PROP_DISPLAY_USE_BPC: + g_value_set_boolean (value, color_config->display_use_black_point_compensation); + break; + case PROP_DISPLAY_OPTIMIZE: + g_value_set_boolean (value, priv->display_optimize); + break; + case PROP_SIMULATION_RENDERING_INTENT: + g_value_set_enum (value, color_config->simulation_intent); + break; + case PROP_SIMULATION_USE_BPC: + g_value_set_boolean (value, color_config->simulation_use_black_point_compensation); + break; + case PROP_SIMULATION_OPTIMIZE: + g_value_set_boolean (value, priv->simulation_optimize); + break; + case PROP_SIMULATION_GAMUT_CHECK: + g_value_set_boolean (value, color_config->simulation_gamut_check); + break; + case PROP_OUT_OF_GAMUT_COLOR: + g_value_set_boxed (value, &color_config->out_of_gamut_color); + break; + case PROP_SHOW_RGB_U8: + g_value_set_boolean (value, priv->show_rgb_u8); + break; + case PROP_SHOW_HSV: + g_value_set_boolean (value, priv->show_hsv); + break; + case PROP_DISPLAY_MODULE: + g_value_set_string (value, color_config->display_module); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + +/* public functions */ + +/** + * gimp_color_config_get_mode: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +GimpColorManagementMode +gimp_color_config_get_mode (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), + GIMP_COLOR_MANAGEMENT_OFF); + + return config->mode; +} + +/** + * gimp_color_config_get_display_intent: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +GimpColorRenderingIntent +gimp_color_config_get_display_intent (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), + GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL); + + return config->display_intent; +} + +/** + * gimp_color_config_get_display_bpc: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +gboolean +gimp_color_config_get_display_bpc (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE); + + return config->display_use_black_point_compensation; +} + +/** + * gimp_color_config_get_display_optimize: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +gboolean +gimp_color_config_get_display_optimize (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE); + + return GET_PRIVATE (config)->display_optimize; +} + +/** + * gimp_color_config_get_display_profile_from_gdk: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +gboolean +gimp_color_config_get_display_profile_from_gdk (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE); + + return config->display_profile_from_gdk; +} + +/** + * gimp_color_config_get_simulation_intent: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +GimpColorRenderingIntent +gimp_color_config_get_simulation_intent (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), + GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL); + + return config->simulation_intent; +} + +/** + * gimp_color_config_get_simulation_bpc: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +gboolean +gimp_color_config_get_simulation_bpc (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE); + + return config->simulation_use_black_point_compensation; +} + +/** + * gimp_color_config_get_simulation_optimize: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +gboolean +gimp_color_config_get_simulation_optimize (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE); + + return GET_PRIVATE (config)->simulation_optimize; +} + +/** + * gimp_color_config_get_simulation_gamut_check: + * @config: a #GimpColorConfig + * + * Since: 2.10 + **/ +gboolean +gimp_color_config_get_simulation_gamut_check (GimpColorConfig *config) +{ + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE); + + return config->simulation_gamut_check; +} + +/** + * gimp_color_config_get_rgb_color_profile: + * @config: a #GimpColorConfig + * @error: return location for a #GError + * + * Since: 2.10 + **/ +GimpColorProfile * +gimp_color_config_get_rgb_color_profile (GimpColorConfig *config, + GError **error) +{ + GimpColorProfile *profile = NULL; + + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + if (config->rgb_profile) + { + GFile *file = gimp_file_new_for_config_path (config->rgb_profile, + error); + + if (file) + { + profile = gimp_color_profile_new_from_file (file, error); + + if (profile && ! gimp_color_profile_is_rgb (profile)) + { + g_object_unref (profile); + profile = NULL; + + g_set_error (error, GIMP_CONFIG_ERROR, 0, + _("Color profile '%s' is not for RGB color space."), + gimp_file_get_utf8_name (file)); + } + + g_object_unref (file); + } + } + + return profile; +} + +/** + * gimp_color_config_get_gray_color_profile: + * @config: a #GimpColorConfig + * @error: return location for a #GError + * + * Since: 2.10 + **/ +GimpColorProfile * +gimp_color_config_get_gray_color_profile (GimpColorConfig *config, + GError **error) +{ + GimpColorProfile *profile = NULL; + + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + if (config->gray_profile) + { + GFile *file = gimp_file_new_for_config_path (config->gray_profile, + error); + + if (file) + { + profile = gimp_color_profile_new_from_file (file, error); + + if (profile && ! gimp_color_profile_is_gray (profile)) + { + g_object_unref (profile); + profile = NULL; + + g_set_error (error, GIMP_CONFIG_ERROR, 0, + _("Color profile '%s' is not for GRAY color space."), + gimp_file_get_utf8_name (file)); + } + + g_object_unref (file); + } + } + + return profile; +} + +/** + * gimp_color_config_get_cmyk_color_profile: + * @config: a #GimpColorConfig + * @error: return location for a #GError + * + * Since: 2.10 + **/ +GimpColorProfile * +gimp_color_config_get_cmyk_color_profile (GimpColorConfig *config, + GError **error) +{ + GimpColorProfile *profile = NULL; + + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + if (config->cmyk_profile) + { + GFile *file = gimp_file_new_for_config_path (config->cmyk_profile, + error); + + if (file) + { + profile = gimp_color_profile_new_from_file (file, error); + + if (profile && ! gimp_color_profile_is_cmyk (profile)) + { + g_object_unref (profile); + profile = NULL; + + g_set_error (error, GIMP_CONFIG_ERROR, 0, + _("Color profile '%s' is not for CMYK color space."), + gimp_file_get_utf8_name (file)); + } + + g_object_unref (file); + } + } + + return profile; +} + +/** + * gimp_color_config_get_display_color_profile: + * @config: a #GimpColorConfig + * @error: return location for a #GError + * + * Since: 2.10 + **/ +GimpColorProfile * +gimp_color_config_get_display_color_profile (GimpColorConfig *config, + GError **error) +{ + GimpColorProfile *profile = NULL; + + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + if (config->display_profile) + { + GFile *file = gimp_file_new_for_config_path (config->display_profile, + error); + + if (file) + { + profile = gimp_color_profile_new_from_file (file, error); + + g_object_unref (file); + } + } + + return profile; +} + +/** + * gimp_color_config_get_simulation_color_profile: + * @config: a #GimpColorConfig + * @error: return location for a #GError + * + * Since: 2.10 + **/ +GimpColorProfile * +gimp_color_config_get_simulation_color_profile (GimpColorConfig *config, + GError **error) +{ + GimpColorProfile *profile = NULL; + + g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), NULL); + g_return_val_if_fail (error == NULL || *error == NULL, NULL); + + if (config->printer_profile) + { + GFile *file = gimp_file_new_for_config_path (config->printer_profile, + error); + + if (file) + { + profile = gimp_color_profile_new_from_file (file, error); + + g_object_unref (file); + } + } + + return profile; +} + + +/* private functions */ + +static void +gimp_color_config_set_rgb_profile (GimpColorConfig *config, + const gchar *filename, + GError **error) +{ + gboolean success = TRUE; + + if (filename) + { + GFile *file = gimp_file_new_for_config_path (filename, error); + + if (file) + { + GimpColorProfile *profile; + + profile = gimp_color_profile_new_from_file (file, error); + + if (profile) + { + if (! gimp_color_profile_is_rgb (profile)) + { + g_set_error (error, GIMP_CONFIG_ERROR, 0, + _("Color profile '%s' is not for RGB " + "color space."), + gimp_file_get_utf8_name (file)); + success = FALSE; + } + + g_object_unref (profile); + } + else + { + success = FALSE; + } + + g_object_unref (file); + } + else + { + success = FALSE; + } + } + + if (success) + { + g_free (config->rgb_profile); + config->rgb_profile = g_strdup (filename); + } +} + +static void +gimp_color_config_set_gray_profile (GimpColorConfig *config, + const gchar *filename, + GError **error) +{ + gboolean success = TRUE; + + if (filename) + { + GFile *file = gimp_file_new_for_config_path (filename, error); + + if (file) + { + GimpColorProfile *profile; + + profile = gimp_color_profile_new_from_file (file, error); + + if (profile) + { + if (! gimp_color_profile_is_gray (profile)) + { + g_set_error (error, GIMP_CONFIG_ERROR, 0, + _("Color profile '%s' is not for GRAY " + "color space."), + gimp_file_get_utf8_name (file)); + success = FALSE; + } + + g_object_unref (profile); + } + else + { + success = FALSE; + } + + g_object_unref (file); + } + else + { + success = FALSE; + } + } + + if (success) + { + g_free (config->gray_profile); + config->gray_profile = g_strdup (filename); + } +} + +static void +gimp_color_config_set_cmyk_profile (GimpColorConfig *config, + const gchar *filename, + GError **error) +{ + gboolean success = TRUE; + + if (filename) + { + GFile *file = gimp_file_new_for_config_path (filename, error); + + if (file) + { + GimpColorProfile *profile; + + profile = gimp_color_profile_new_from_file (file, error); + + if (profile) + { + if (! gimp_color_profile_is_cmyk (profile)) + { + g_set_error (error, GIMP_CONFIG_ERROR, 0, + _("Color profile '%s' is not for CMYK " + "color space."), + gimp_file_get_utf8_name (file)); + success = FALSE; + } + + g_object_unref (profile); + } + else + { + success = FALSE; + } + + g_object_unref (file); + } + else + { + success = FALSE; + } + } + + if (success) + { + g_free (config->cmyk_profile); + config->cmyk_profile = g_strdup (filename); + } +} + +static void +gimp_color_config_set_display_profile (GimpColorConfig *config, + const gchar *filename, + GError **error) +{ + gboolean success = TRUE; + + if (filename) + { + GFile *file = gimp_file_new_for_config_path (filename, error); + + if (file) + { + GimpColorProfile *profile; + + profile = gimp_color_profile_new_from_file (file, error); + + if (profile) + { + g_object_unref (profile); + } + else + { + success = FALSE; + } + + g_object_unref (file); + } + else + { + success = FALSE; + } + } + + if (success) + { + g_free (config->display_profile); + config->display_profile = g_strdup (filename); + } +} + +static void +gimp_color_config_set_simulation_profile (GimpColorConfig *config, + const gchar *filename, + GError **error) +{ + gboolean success = TRUE; + + if (filename) + { + GFile *file = gimp_file_new_for_config_path (filename, error); + + if (file) + { + GimpColorProfile *profile; + + profile = gimp_color_profile_new_from_file (file, error); + + if (profile) + { + g_object_unref (profile); + } + else + { + success = FALSE; + } + + g_object_unref (file); + } + else + { + success = FALSE; + } + } + + if (success) + { + g_free (config->printer_profile); + config->printer_profile = g_strdup (filename); + } +} -- cgit v1.2.3