static void color_profile_dest_changed (GtkWidget *combo, ProfileDialog *dialog) { GimpColorProfile *dest_profile = NULL; GFile *file; GError *error = NULL; file = gimp_color_profile_combo_box_get_active_file (GIMP_COLOR_PROFILE_COMBO_BOX (combo)); if (file) { dest_profile = gimp_color_profile_new_from_file (file, &error); g_object_unref (file); } else { dest_profile = gimp_image_get_builtin_color_profile (dialog->image); g_object_ref (dest_profile); } if (! dest_profile) { gimp_color_profile_view_set_error (GIMP_COLOR_PROFILE_VIEW (dialog->dest_view), error->message); g_clear_error (&error); } else { gimp_color_profile_view_set_profile (GIMP_COLOR_PROFILE_VIEW (dialog->dest_view), dest_profile); g_object_unref (dest_profile); } }
gboolean gimp_image_validate_color_profile (GimpImage *image, GimpColorProfile *profile, gboolean *is_builtin, GError **error) { g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (profile), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (gimp_image_get_base_type (image) == GIMP_GRAY) { if (! gimp_color_profile_is_gray (profile)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("ICC profile validation failed: " "Color profile is not for GRAY color space")); return FALSE; } } else { if (! gimp_color_profile_is_rgb (profile)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("ICC profile validation failed: " "Color profile is not for RGB color space")); return FALSE; } } if (is_builtin) { GimpColorProfile *builtin; builtin = gimp_image_get_builtin_color_profile (image); *is_builtin = gimp_color_profile_is_equal (profile, builtin); } return TRUE; }
void gimp_image_import_color_profile (GimpImage *image, GimpContext *context, GimpProgress *progress, gboolean interactive) { GimpColorConfig *config = image->gimp->config->color_management; g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (GIMP_IS_CONTEXT (context)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); config = image->gimp->config->color_management; if (gimp_image_get_base_type (image) == GIMP_GRAY) return; if (config->mode == GIMP_COLOR_MANAGEMENT_OFF) return; if (gimp_image_get_color_profile (image)) { GimpColorProfilePolicy policy; GimpColorProfile *dest_profile = NULL; policy = image->gimp->config->color_profile_policy; if (policy == GIMP_COLOR_PROFILE_POLICY_ASK) { if (interactive) { gboolean dont_ask = FALSE; policy = gimp_query_profile_policy (image->gimp, image, context, &dest_profile, &dont_ask); if (dont_ask) { g_object_set (G_OBJECT (image->gimp->config), "color-profile-policy", policy, NULL); } } else { policy = GIMP_COLOR_PROFILE_POLICY_KEEP; } } if (policy == GIMP_COLOR_PROFILE_POLICY_CONVERT) { GimpColorRenderingIntent intent; gboolean bpc; if (! dest_profile) { dest_profile = gimp_image_get_builtin_color_profile (image); g_object_ref (dest_profile); } intent = config->display_intent; bpc = (intent == GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC); gimp_image_undo_disable (image); gimp_image_convert_color_profile (image, dest_profile, intent, bpc, progress, NULL); gimp_image_clean_all (image); gimp_image_undo_enable (image); g_object_unref (dest_profile); } } }
GtkWidget * color_profile_dialog_new (ColorProfileDialogType dialog_type, GimpImage *image, GimpContext *context, GtkWidget *parent, GimpProgress *progress) { ProfileDialog *dialog; GtkWidget *frame; GtkWidget *vbox; GtkWidget *expander; GtkWidget *label; GimpColorProfile *src_profile; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); dialog = g_slice_new0 (ProfileDialog); dialog->dialog_type = dialog_type; dialog->image = image; dialog->progress = progress; dialog->config = image->gimp->config->color_management; if (saved_intent == -1) { dialog->intent = GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC; dialog->bpc = TRUE; } else { dialog->intent = saved_intent; dialog->bpc = saved_bpc; } switch (dialog_type) { const Babl *format; case COLOR_PROFILE_DIALOG_ASSIGN_PROFILE: dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Assign ICC Color Profile"), "gimp-image-color-profile-assign", NULL, _("Assign a color profile to the image"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_COLOR_PROFILE_ASSIGN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Assign"), GTK_RESPONSE_OK, NULL); dialog->builtin_profile = gimp_image_get_builtin_color_profile (dialog->image); break; case COLOR_PROFILE_DIALOG_CONVERT_TO_PROFILE: dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Convert to ICC Color Profile"), "gimp-image-color-profile-convert", NULL, _("Convert the image to a color profile"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_COLOR_PROFILE_CONVERT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CONVERT, GTK_RESPONSE_OK, NULL); dialog->builtin_profile = gimp_image_get_builtin_color_profile (dialog->image); break; case COLOR_PROFILE_DIALOG_CONVERT_TO_RGB: dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("RGB Conversion"), "gimp-image-convert-rgb", GIMP_STOCK_CONVERT_RGB, _("Convert Image to RGB"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_CONVERT_RGB, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CONVERT, GTK_RESPONSE_OK, NULL); format = gimp_babl_format (GIMP_RGB, gimp_image_get_precision (dialog->image), TRUE); dialog->builtin_profile = gimp_babl_format_get_color_profile (format); break; case COLOR_PROFILE_DIALOG_CONVERT_TO_GRAY: dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Grayscale Conversion"), "gimp-image-convert-gray", GIMP_STOCK_CONVERT_GRAYSCALE, _("Convert Image to Grayscale"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_CONVERT_GRAYSCALE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CONVERT, GTK_RESPONSE_OK, NULL); format = gimp_babl_format (GIMP_GRAY, gimp_image_get_precision (dialog->image), TRUE); dialog->builtin_profile = gimp_babl_format_get_color_profile (format); break; } gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) color_profile_dialog_free, dialog); g_signal_connect (dialog->dialog, "response", G_CALLBACK (color_profile_dialog_response), dialog); dialog->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (dialog->main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), dialog->main_vbox, TRUE, TRUE, 0); gtk_widget_show (dialog->main_vbox); frame = gimp_frame_new (_("Current Color Profile")); gtk_box_pack_start (GTK_BOX (dialog->main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); src_profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (image)); label = gimp_color_profile_label_new (src_profile); gtk_container_add (GTK_CONTAINER (frame), label); gtk_widget_show (label); frame = gimp_frame_new (dialog_type == COLOR_PROFILE_DIALOG_ASSIGN_PROFILE ? _("Assign") : _("Convert to")); gtk_box_pack_start (GTK_BOX (dialog->main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); dialog->combo = color_profile_combo_box_new (dialog); gtk_box_pack_start (GTK_BOX (vbox), dialog->combo, FALSE, FALSE, 0); gtk_widget_show (dialog->combo); expander = gtk_expander_new_with_mnemonic (_("Profile _details")); gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); gtk_widget_show (expander); dialog->dest_view = gimp_color_profile_view_new (); gtk_container_add (GTK_CONTAINER (expander), dialog->dest_view); gtk_widget_show (dialog->dest_view); g_signal_connect (dialog->combo, "changed", G_CALLBACK (color_profile_dest_changed), dialog); color_profile_dest_changed (dialog->combo, dialog); if (dialog_type == COLOR_PROFILE_DIALOG_CONVERT_TO_PROFILE) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *combo; GtkWidget *toggle; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (dialog->main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("_Rendering Intent:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_enum_combo_box_new (GIMP_TYPE_COLOR_RENDERING_INTENT); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dialog->intent, G_CALLBACK (gimp_int_combo_box_get_active), &dialog->intent); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); toggle = gtk_check_button_new_with_mnemonic (_("_Black Point Compensation")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->bpc); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->bpc); } return dialog->dialog; }
void gimp_image_convert_precision (GimpImage *image, GimpPrecision precision, gint layer_dither_type, gint text_layer_dither_type, gint mask_dither_type, GimpProgress *progress) { GimpColorProfile *old_profile; GimpColorProfile *new_profile = NULL; const Babl *old_format; const Babl *new_format; GList *all_drawables; GList *list; const gchar *undo_desc = NULL; GimpProgress *sub_progress = NULL; gint nth_drawable, n_drawables; g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (precision != gimp_image_get_precision (image)); g_return_if_fail (precision == GIMP_PRECISION_U8_GAMMA || gimp_image_get_base_type (image) != GIMP_INDEXED); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); all_drawables = g_list_concat (gimp_image_get_layer_list (image), gimp_image_get_channel_list (image)); n_drawables = g_list_length (all_drawables) + 1 /* + selection */; if (progress) sub_progress = gimp_sub_progress_new (progress); switch (precision) { case GIMP_PRECISION_U8_LINEAR: undo_desc = C_("undo-type", "Convert Image to 8 bit linear integer"); break; case GIMP_PRECISION_U8_GAMMA: undo_desc = C_("undo-type", "Convert Image to 8 bit gamma integer"); break; case GIMP_PRECISION_U16_LINEAR: undo_desc = C_("undo-type", "Convert Image to 16 bit linear integer"); break; case GIMP_PRECISION_U16_GAMMA: undo_desc = C_("undo-type", "Convert Image to 16 bit gamma integer"); break; case GIMP_PRECISION_U32_LINEAR: undo_desc = C_("undo-type", "Convert Image to 32 bit linear integer"); break; case GIMP_PRECISION_U32_GAMMA: undo_desc = C_("undo-type", "Convert Image to 32 bit gamma integer"); break; case GIMP_PRECISION_HALF_LINEAR: undo_desc = C_("undo-type", "Convert Image to 16 bit linear floating point"); break; case GIMP_PRECISION_HALF_GAMMA: undo_desc = C_("undo-type", "Convert Image to 16 bit gamma floating point"); break; case GIMP_PRECISION_FLOAT_LINEAR: undo_desc = C_("undo-type", "Convert Image to 32 bit linear floating point"); break; case GIMP_PRECISION_FLOAT_GAMMA: undo_desc = C_("undo-type", "Convert Image to 32 bit gamma floating point"); break; case GIMP_PRECISION_DOUBLE_LINEAR: undo_desc = C_("undo-type", "Convert Image to 64 bit linear floating point"); break; case GIMP_PRECISION_DOUBLE_GAMMA: undo_desc = C_("undo-type", "Convert Image to 64 bit gamma floating point"); break; } if (progress) gimp_progress_start (progress, FALSE, "%s", undo_desc); g_object_freeze_notify (G_OBJECT (image)); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_CONVERT, undo_desc); /* Push the image precision to the stack */ gimp_image_undo_push_image_precision (image, NULL); old_profile = gimp_image_get_color_profile (image); old_format = gimp_image_get_layer_format (image, FALSE); /* Set the new precision */ g_object_set (image, "precision", precision, NULL); new_format = gimp_image_get_layer_format (image, FALSE); if (old_profile && gimp_babl_format_get_linear (old_format) != gimp_babl_format_get_linear (new_format)) { GimpColorProfile *new_profile; /* when converting between linear and gamma, we create a new * profile using the original profile's chromacities and * whitepoint, but a linear/sRGB-gamma TRC. */ if (gimp_babl_format_get_linear (new_format)) { new_profile = gimp_color_profile_new_linear_from_color_profile (old_profile); } else { new_profile = gimp_color_profile_new_srgb_trc_from_color_profile (old_profile); } /* if a new profile cannot be be generated, convert to the * builtin profile, which is better than leaving the user with * broken colors */ if (! new_profile) { new_profile = gimp_image_get_builtin_color_profile (image); g_object_ref (new_profile); } } for (list = all_drawables, nth_drawable = 0; list; list = g_list_next (list), nth_drawable++) { GimpDrawable *drawable = list->data; gint dither_type; if (gimp_item_is_text_layer (GIMP_ITEM (drawable))) dither_type = text_layer_dither_type; else dither_type = layer_dither_type; if (sub_progress) gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (sub_progress), nth_drawable, n_drawables); gimp_drawable_convert_type (drawable, image, gimp_drawable_get_base_type (drawable), precision, new_profile, dither_type, mask_dither_type, TRUE, sub_progress); } g_list_free (all_drawables); if (old_profile) { gimp_image_set_color_profile (image, new_profile, NULL); g_object_unref (new_profile); } /* convert the selection mask */ { GimpChannel *mask = gimp_image_get_mask (image); GeglBuffer *buffer; if (sub_progress) gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (sub_progress), nth_drawable, n_drawables); gimp_image_undo_push_mask_precision (image, NULL, mask); buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, gimp_image_get_width (image), gimp_image_get_height (image)), gimp_image_get_mask_format (image)); gegl_buffer_copy (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)), NULL, GEGL_ABYSS_NONE, buffer, NULL); gimp_drawable_set_buffer (GIMP_DRAWABLE (mask), FALSE, NULL, buffer); g_object_unref (buffer); nth_drawable++; } if (sub_progress) gimp_progress_set_value (sub_progress, 1.0); gimp_image_undo_group_end (image); gimp_image_precision_changed (image); g_object_thaw_notify (G_OBJECT (image)); if (sub_progress) g_object_unref (sub_progress); if (progress) gimp_progress_end (progress); }
static void color_profile_dialog_response (GtkWidget *widget, gint response_id, ProfileDialog *dialog) { gboolean success = TRUE; GError *error = NULL; if (response_id == GTK_RESPONSE_OK) { GimpColorProfile *dest_profile = NULL; GFile *file; file = gimp_color_profile_combo_box_get_active_file (GIMP_COLOR_PROFILE_COMBO_BOX (dialog->combo)); if (file) { dest_profile = gimp_color_profile_new_from_file (file, &error); if (! dest_profile) success = FALSE; g_object_unref (file); } else { dest_profile = gimp_image_get_builtin_color_profile (dialog->image); g_object_ref (dest_profile); } if (success) { if (dialog->convert) { GimpProgress *progress; const gchar *label; label = gimp_color_profile_get_label (dest_profile); progress = gimp_progress_start (dialog->progress, FALSE, _("Converting to '%s'"), label); success = gimp_image_convert_color_profile (dialog->image, dest_profile, dialog->intent, dialog->bpc, progress, &error); if (progress) gimp_progress_end (progress); if (success) { saved_intent = dialog->intent; saved_bpc = dialog->bpc; } } else { gimp_image_undo_group_start (dialog->image, GIMP_UNDO_GROUP_PARASITE_ATTACH, _("Assign color profile")); success = gimp_image_set_color_profile (dialog->image, dest_profile, &error); /* omg... */ if (success) gimp_image_parasite_detach (dialog->image, "icc-profile-name"); gimp_image_undo_group_end (dialog->image); if (! success) gimp_image_undo (dialog->image); } if (success) gimp_image_flush (dialog->image); g_object_unref (dest_profile); } } if (success) { gtk_widget_destroy (dialog->dialog); } else { gimp_message (dialog->image->gimp, G_OBJECT (dialog->dialog), GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } }
static GtkWidget * color_profile_combo_box_new (ProfileDialog *dialog) { GtkWidget *combo; GtkWidget *chooser; gchar *history; GimpColorProfile *profile; gchar *label; GError *error = NULL; chooser = gimp_color_profile_chooser_dialog_new (_("Select destination profile")); history = gimp_personal_rc_file ("profilerc"); combo = gimp_color_profile_combo_box_new (chooser, history); g_free (history); profile = gimp_image_get_builtin_color_profile (dialog->image); if (gimp_image_get_base_type (dialog->image) == GIMP_GRAY) { label = g_strdup_printf (_("Built-in grayscale (%s)"), gimp_color_profile_get_label (profile)); profile = gimp_color_config_get_gray_color_profile (dialog->config, &error); } else { label = g_strdup_printf (_("Built-in RGB (%s)"), gimp_color_profile_get_label (profile)); profile = gimp_color_config_get_rgb_color_profile (dialog->config, &error); } gimp_color_profile_combo_box_add_file (GIMP_COLOR_PROFILE_COMBO_BOX (combo), NULL, label); g_free (label); if (profile) { GFile *file = g_file_new_for_path (dialog->config->rgb_profile); if (gimp_image_get_base_type (dialog->image) == GIMP_GRAY) { label = g_strdup_printf (_("Preferred grayscale (%s)"), gimp_color_profile_get_label (profile)); } else { label = g_strdup_printf (_("Preferred RGB (%s)"), gimp_color_profile_get_label (profile)); } g_object_unref (profile); gimp_color_profile_combo_box_add_file (GIMP_COLOR_PROFILE_COMBO_BOX (combo), file, label); g_object_unref (file); g_free (label); } else if (error) { gimp_message (dialog->image->gimp, G_OBJECT (dialog->dialog), GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } gimp_color_profile_combo_box_set_active_file (GIMP_COLOR_PROFILE_COMBO_BOX (combo), NULL, NULL); return combo; }
GimpColorProfilePolicy color_profile_import_dialog_run (GimpImage *image, GimpContext *context, GtkWidget *parent, GimpColorProfile **dest_profile, gboolean *dont_ask) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *label; GtkWidget *toggle; GimpColorProfile *src_profile; GimpColorProfilePolicy policy; const gchar *title; const gchar *frame_title; gchar *text; g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_COLOR_PROFILE_POLICY_KEEP); g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_COLOR_PROFILE_POLICY_KEEP); g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), GIMP_COLOR_PROFILE_POLICY_KEEP); g_return_val_if_fail (dest_profile != NULL, GIMP_COLOR_PROFILE_POLICY_KEEP); src_profile = gimp_image_get_color_profile (image); *dest_profile = gimp_image_get_builtin_color_profile (image); if (gimp_image_get_base_type (image) == GIMP_GRAY) { title = _("Convert to Grayscale Working Space?"); frame_title = _("Convert the image to the grayscale working space?"); } else { title = _("Convert to RGB Working Space?"); frame_title = _("Convert the image to the RGB working space?"); } dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, title, "gimp-image-color-profile-import", NULL, _("Import the image from a color profile"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_COLOR_PROFILE_IMPORT, _("Keep"), GTK_RESPONSE_CANCEL, _("Convert"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); text = g_strdup_printf (_("The image '%s' has an embedded color profile"), gimp_image_get_display_name (image)); frame = gimp_frame_new (text); g_free (text); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); label = gimp_color_profile_label_new (src_profile); gtk_container_add (GTK_CONTAINER (frame), label); gtk_widget_show (label); frame = gimp_frame_new (frame_title); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); label = gimp_color_profile_label_new (*dest_profile); gtk_container_add (GTK_CONTAINER (frame), label); gtk_widget_show (label); if (dont_ask) { toggle = gtk_check_button_new_with_mnemonic (_("_Don't ask me again")); gtk_box_pack_end (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE); gtk_widget_show (toggle); } switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_OK: policy = GIMP_COLOR_PROFILE_POLICY_CONVERT; g_object_ref (*dest_profile); break; default: policy = GIMP_COLOR_PROFILE_POLICY_KEEP; break; } if (dont_ask) { *dont_ask = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)); } gtk_widget_destroy (dialog); return policy; }