static WidgetInfo *
create_enum_combo_box (void)
{
GtkWidget *vbox;
GtkWidget *combo;
GtkWidget *align;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
align = gtk_alignment_new (0.5, 0.5, 0.5, 0.0);
combo = gimp_enum_combo_box_new (GIMP_TYPE_CHANNEL_TYPE);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), GIMP_BLUE_CHANNEL);
gtk_container_add (GTK_CONTAINER (align), combo);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Enum Combo Box"), FALSE, FALSE, 0);
return new_widget_info ("gimp-widget-enum-combo-box", vbox, SMALL);
}
static void
gimp_dynamics_editor_init (GimpDynamicsEditor *editor)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
editor->dynamics_model = g_object_new (GIMP_TYPE_DYNAMICS, NULL);
g_signal_connect (editor->dynamics_model, "notify",
G_CALLBACK (gimp_dynamics_editor_notify_model),
editor);
editor->view_selector =
gimp_enum_combo_box_new (GIMP_TYPE_DYNAMICS_OUTPUT_TYPE);
gtk_box_pack_start (GTK_BOX (data_editor), editor->view_selector,
FALSE, FALSE, 0);
gtk_widget_show (editor->view_selector);
editor->notebook = gtk_notebook_new ();
gtk_notebook_set_show_border (GTK_NOTEBOOK (editor->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (editor->notebook), FALSE);
gtk_box_pack_start (GTK_BOX (editor), editor->notebook, TRUE, TRUE, 0);
gtk_widget_show (editor->notebook);
}
GtkWidget* bimp_resize_gui_new(resize_settings settings)
{
GtkWidget *gui, *vbox_dimensions, *hbox_padding, *vbox_resolution, *hbox_values, *hbox_quality;
GtkWidget *align_manualsize, *align_values, *align_res;
GtkWidget *label_width, *label_height, *label_quality, *label_resX, *label_resY, *label_dpi;
last_percent_w_value = settings->new_w_pc;
last_percent_h_value = settings->new_h_pc;
last_pixel_w_value = settings->new_w_px;
last_pixel_h_value = settings->new_h_px;
gui = gtk_hbox_new(FALSE, 10);
// "change dimensions" side
vbox_dimensions = gtk_vbox_new(FALSE, 5);
radio_size_percent = gtk_radio_button_new_with_label (NULL, _("Set to a percentage of the original"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_size_percent), (settings->resize_mode == RESIZE_PERCENT));
radio_size_px = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_size_percent), _("Set exact size in pixel"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_size_px), (settings->resize_mode != RESIZE_PERCENT));
align_manualsize = gtk_alignment_new(0, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_manualsize), 0, 5, 20, 0);
combo_manualsize = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_manualsize), _("For both dimensions"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_manualsize), _("Width only"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_manualsize), _("Height only"));
if (settings->resize_mode == RESIZE_PIXEL_WIDTH) gtk_combo_box_set_active(GTK_COMBO_BOX(combo_manualsize), 1);
else if (settings->resize_mode == RESIZE_PIXEL_HEIGHT) gtk_combo_box_set_active(GTK_COMBO_BOX(combo_manualsize), 2);
else gtk_combo_box_set_active(GTK_COMBO_BOX(combo_manualsize), 0);
gtk_container_add(GTK_CONTAINER(align_manualsize), combo_manualsize);
GtkWidget* separator1 = gtk_hseparator_new();
radio_stretch_allow = gtk_radio_button_new_with_label (NULL, _("Allow stretching"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_stretch_allow), (settings->stretch_mode == STRETCH_ALLOW));
radio_stretch_aspect = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_stretch_allow), _("Preserve aspect ratio"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_stretch_aspect), (settings->stretch_mode == STRETCH_ASPECT));
radio_stretch_padded = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_stretch_allow), _("Fill with padding"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_stretch_padded), (settings->stretch_mode == STRETCH_PADDED));
chooser_paddingcolor = gtk_color_button_new_with_color(&(settings->padding_color));
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(chooser_paddingcolor), TRUE);
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(chooser_paddingcolor), settings->padding_color_alpha);
hbox_padding = gtk_hbox_new(FALSE, 5);
GtkWidget* separator2 = gtk_hseparator_new();
align_values = gtk_alignment_new(0.5, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_values), 5, 5, 0, 0);
hbox_values = gtk_hbox_new(FALSE, 5);
label_width = gtk_label_new(g_strconcat(_("Width"), ":", NULL));
spin_width = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_width, SPIN_SIZE_W, SPIN_SIZE_H);
label_height = gtk_label_new(g_strconcat(_("Height"), ":", NULL));
spin_height = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_height, SPIN_SIZE_W, SPIN_SIZE_H);
label_unit = gtk_label_new("<unit>");
gtk_widget_set_size_request (label_unit, 25, 25);
hbox_quality = gtk_hbox_new(FALSE, 5);
label_quality = gtk_label_new(_("Interpolation quality"));
combo_quality = gimp_enum_combo_box_new((GType)GIMP_TYPE_INTERPOLATION_TYPE);
gimp_int_combo_box_set_active((GimpIntComboBox*)combo_quality, settings->interpolation);
GtkWidget* separator3 = gtk_vseparator_new();
// "change resolution" side
vbox_resolution = gtk_vbox_new(FALSE, 5);
check_resolution = gtk_check_button_new_with_label(_("Change resolution"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_resolution), settings->change_res);
align_res = gtk_alignment_new(0.5, 0, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align_res), 5, 5, 0, 0);
hbox_res = gtk_hbox_new(FALSE, 5);
label_resX = gtk_label_new(g_strconcat(_("X axis"), ":", NULL));
spin_resX = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_resX, SPIN_SIZE_W, SPIN_SIZE_H);
gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_resX), GTK_ADJUSTMENT(gtk_adjustment_new (settings->new_res_x, 0.005, 65536.000, 1.000, 1, 0)), 0, 3);
label_resY = gtk_label_new(g_strconcat(_("Y axis"), ":", NULL));
spin_resY = gtk_spin_button_new(NULL, 1, 0);
gtk_widget_set_size_request (spin_resY, SPIN_SIZE_W, SPIN_SIZE_H);
gtk_spin_button_configure (GTK_SPIN_BUTTON(spin_resY), GTK_ADJUSTMENT(gtk_adjustment_new (settings->new_res_y, 0.005, 65536.000, 1.000, 1, 0)), 0, 3);
label_dpi = gtk_label_new("dpi");
// pack everything
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_size_percent, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_size_px, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), align_manualsize, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), separator1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_stretch_allow, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), radio_stretch_aspect, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_padding), radio_stretch_padded, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_padding), chooser_paddingcolor, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), hbox_padding, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), separator2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), label_width, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), spin_width, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), label_height, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), spin_height, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_values), label_unit, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_values), hbox_values);
gtk_box_pack_start(GTK_BOX(hbox_quality), label_quality, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_quality), combo_quality, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), align_values, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_dimensions), hbox_quality, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_resolution), check_resolution, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), label_resX, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), spin_resX, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), label_resY, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), spin_resY, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_res), label_dpi, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(align_res), hbox_res);
gtk_box_pack_start(GTK_BOX(vbox_resolution), align_res, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), vbox_dimensions, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), separator3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(gui), vbox_resolution, FALSE, FALSE, 0);
previous_was_percent = FALSE;
toggle_units_group(NULL, NULL);
toggle_resolution(NULL, NULL);
g_signal_connect(G_OBJECT(radio_size_percent), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_size_px), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(combo_manualsize), "changed", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_stretch_allow), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_stretch_aspect), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(radio_stretch_padded), "toggled", G_CALLBACK(toggle_units_group), NULL);
g_signal_connect(G_OBJECT(check_resolution), "toggled", G_CALLBACK(toggle_resolution), NULL);
return gui;
}
EnumWidget(GType enumType, gint defaultItem)
: gimpEnumComboBox(GIMP_ENUM_COMBO_BOX(gimp_enum_combo_box_new(enumType)))
{
g_object_ref_sink(G_OBJECT(this->gimpEnumComboBox));
gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(this->gimpEnumComboBox), defaultItem);
}
static GimpPDBStatusType
lcms_dialog (GimpColorConfig *config,
gint32 image,
gboolean apply,
LcmsValues *values)
{
GimpColorProfileComboBox *box;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *combo;
cmsHPROFILE src_profile;
gchar *name;
gboolean success = FALSE;
gboolean run;
src_profile = lcms_image_get_profile (config, image, NULL);
if (src_profile && ! lcms_icc_profile_is_rgb (src_profile))
{
g_printerr ("lcms: attached color profile is not for RGB color space "
"(skipping)\n");
cmsCloseProfile (src_profile);
src_profile = NULL;
}
if (! src_profile)
src_profile = cmsCreate_sRGBProfile ();
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (apply ?
_("Convert to ICC Color Profile") :
_("Assign ICC Color Profile"),
PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func,
apply ? PLUG_IN_PROC_APPLY : PLUG_IN_PROC_SET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
apply ? GTK_STOCK_CONVERT : _("_Assign"),
GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
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);
frame = gimp_frame_new (_("Current Color Profile"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
name = lcms_icc_profile_get_desc (src_profile);
if (! name)
name = lcms_icc_profile_get_name (src_profile);
label = gtk_label_new (name);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_show (label);
g_free (name);
frame = gimp_frame_new (apply ? _("Convert to") : _("Assign"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
combo = lcms_icc_combo_box_new (config, NULL);
gtk_container_add (GTK_CONTAINER (frame), combo);
gtk_widget_show (combo);
box = GIMP_COLOR_PROFILE_COMBO_BOX (combo);
if (apply)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *toggle;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (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),
values->intent,
G_CALLBACK (gimp_int_combo_box_get_active),
&values->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), values->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),
&values->bpc);
}
while ((run = gimp_dialog_run (GIMP_DIALOG (dialog))) == GTK_RESPONSE_OK)
{
gchar *filename = gimp_color_profile_combo_box_get_active (box);
cmsHPROFILE dest_profile;
gtk_widget_set_sensitive (dialog, FALSE);
if (filename)
{
dest_profile = lcms_load_profile (filename, NULL);
}
else
{
dest_profile = cmsCreate_sRGBProfile ();
}
if (dest_profile)
{
if (lcms_icc_profile_is_rgb (dest_profile))
{
if (apply)
success = lcms_image_apply_profile (image,
src_profile, dest_profile,
filename,
values->intent,
values->bpc);
else
success = lcms_image_set_profile (image,
dest_profile, filename, TRUE);
}
else
{
gimp_message (_("Destination profile is not for RGB color space."));
}
cmsCloseProfile (dest_profile);
}
if (success)
break;
else
gtk_widget_set_sensitive (dialog, TRUE);
}
gtk_widget_destroy (dialog);
cmsCloseProfile (src_profile);
return (run ?
(success ? GIMP_PDB_SUCCESS : GIMP_PDB_EXECUTION_ERROR) :
GIMP_PDB_CANCEL);
}
static void
gimp_color_frame_init (GimpColorFrame *frame)
{
GtkWidget *vbox;
GtkWidget *vbox2;
gint i;
frame->sample_valid = FALSE;
frame->sample_format = babl_format ("R'G'B' u8");
gimp_rgba_set (&frame->color, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
frame->menu = gimp_enum_combo_box_new (GIMP_TYPE_COLOR_FRAME_MODE);
gtk_frame_set_label_widget (GTK_FRAME (frame), frame->menu);
gtk_widget_show (frame->menu);
g_signal_connect (frame->menu, "changed",
G_CALLBACK (gimp_color_frame_menu_callback),
frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
frame->color_area =
g_object_new (GIMP_TYPE_COLOR_AREA,
"color", &frame->color,
"type", GIMP_COLOR_AREA_SMALL_CHECKS,
"drag-mask", GDK_BUTTON1_MASK,
"draw-border", TRUE,
"height-request", 20,
NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame->color_area, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_set_homogeneous (GTK_BOX (vbox2), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
gtk_widget_show (vbox2);
for (i = 0; i < GIMP_COLOR_FRAME_ROWS; i++)
{
GtkWidget *hbox;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
frame->name_labels[i] = gtk_label_new (" ");
gtk_label_set_xalign (GTK_LABEL (frame->name_labels[i]), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), frame->name_labels[i],
FALSE, FALSE, 0);
gtk_widget_show (frame->name_labels[i]);
frame->value_labels[i] = gtk_label_new (" ");
gtk_label_set_selectable (GTK_LABEL (frame->value_labels[i]), TRUE);
gtk_label_set_xalign (GTK_LABEL (frame->value_labels[i]), 1.0);
gtk_box_pack_end (GTK_BOX (hbox), frame->value_labels[i],
FALSE, FALSE, 0);
gtk_widget_show (frame->value_labels[i]);
}
}
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;
}
GtkWidget *
convert_precision_dialog_new (GimpImage *image,
GimpContext *context,
GtkWidget *parent,
GimpPrecision precision,
GimpProgress *progress)
{
ConvertDialog *dialog;
GtkWidget *button;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *combo;
GtkSizeGroup *size_group;
const gchar *enum_desc;
gchar *blurb;
GType dither_type;
const Babl *format;
gint bits;
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 (ConvertDialog);
/* a random format with precision */
format = gimp_babl_format (GIMP_RGB, precision, FALSE);
bits = (babl_format_get_bytes_per_pixel (format) * 8 /
babl_format_get_n_components (format));
dialog->image = image;
dialog->progress = progress;
dialog->precision = precision;
dialog->bits = bits;
/* gegl:color-reduction only does 16 bits */
if (bits <= 16)
{
dialog->layer_dither_type = saved_layer_dither_type;
dialog->text_layer_dither_type = saved_text_layer_dither_type;
dialog->mask_dither_type = saved_mask_dither_type;
}
gimp_enum_get_value (GIMP_TYPE_PRECISION, precision,
NULL, NULL, &enum_desc, NULL);
blurb = g_strdup_printf (_("Convert Image to %s"), enum_desc);
dialog->dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
_("Precision Conversion"),
"gimp-image-convert-precision",
GIMP_STOCK_CONVERT_PRECISION,
blurb,
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_CONVERT_PRECISION,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
g_free (blurb);
button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog),
_("C_onvert"), GTK_RESPONSE_OK);
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_icon_name (GIMP_STOCK_CONVERT_PRECISION,
GTK_ICON_SIZE_BUTTON));
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) convert_precision_dialog_free, dialog);
g_signal_connect (dialog->dialog, "response",
G_CALLBACK (convert_precision_dialog_response),
dialog);
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->dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
/* dithering */
dither_type = gimp_gegl_get_op_enum_type ("gegl:color-reduction",
"dither-strategy");
frame = gimp_frame_new (_("Dithering"));
gtk_box_pack_start (GTK_BOX (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);
/* gegl:color-reduction only does 16 bits */
gtk_widget_set_sensitive (vbox, bits <= 16);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* layers */
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 (_("_Layers:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_size_group_add_widget (size_group, label);
gtk_widget_show (label);
combo = gimp_enum_combo_box_new (dither_type);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
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->layer_dither_type,
G_CALLBACK (gimp_int_combo_box_get_active),
&dialog->layer_dither_type);
/* text layers */
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 (_("_Text Layers:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_size_group_add_widget (size_group, label);
gtk_widget_show (label);
combo = gimp_enum_combo_box_new (dither_type);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
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->text_layer_dither_type,
G_CALLBACK (gimp_int_combo_box_get_active),
&dialog->text_layer_dither_type);
gimp_help_set_help_data (combo,
_("Dithering text layers will make them uneditable"),
NULL);
/* channels */
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 (_("_Channels and Masks:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_size_group_add_widget (size_group, label);
gtk_widget_show (label);
combo = gimp_enum_combo_box_new (dither_type);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
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->mask_dither_type,
G_CALLBACK (gimp_int_combo_box_get_active),
&dialog->mask_dither_type);
g_object_unref (size_group);
return dialog->dialog;
}
static void
gimp_curves_tool_dialog (GimpImageMapTool *image_map_tool)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool);
GimpCurvesConfig *config = tool->config;
GtkListStore *store;
GtkSizeGroup *label_group;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *hbox2;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *button;
GtkWidget *bar;
GtkWidget *combo;
g_signal_connect (image_map_tool->settings_box, "file-dialog-setup",
G_CALLBACK (gimp_curves_tool_export_setup),
image_map_tool);
main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool);
label_group = gimp_image_map_tool_dialog_get_label_group (image_map_tool);
/* The combo box for selecting channels */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Cha_nnel:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_size_group_add_widget (label_group, label);
store = gimp_enum_store_new_with_range (GIMP_TYPE_HISTOGRAM_CHANNEL,
GIMP_HISTOGRAM_VALUE,
GIMP_HISTOGRAM_ALPHA);
tool->channel_menu =
gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store));
g_object_unref (store);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu),
config->channel);
gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (tool->channel_menu),
"gimp-channel");
gtk_box_pack_start (GTK_BOX (hbox), tool->channel_menu, FALSE, FALSE, 0);
gtk_widget_show (tool->channel_menu);
g_signal_connect (tool->channel_menu, "changed",
G_CALLBACK (curves_channel_callback),
tool);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), tool->channel_menu);
button = gtk_button_new_with_mnemonic (_("R_eset Channel"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (curves_channel_reset_callback),
tool);
/* The histogram scale radio buttons */
hbox2 = gimp_prop_enum_stock_box_new (G_OBJECT (tool_options),
"histogram-scale", "gimp-histogram",
0, 0);
gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
gtk_widget_show (hbox2);
/* The table for the color bars and the graph */
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (main_vbox), table, TRUE, TRUE, 0);
/* The left color bar */
vbox = gtk_vbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), vbox, 0, 1, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (vbox);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, RADIUS);
gtk_widget_show (frame);
tool->yrange = gimp_color_bar_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_set_size_request (tool->yrange, BAR_SIZE, -1);
gtk_container_add (GTK_CONTAINER (frame), tool->yrange);
gtk_widget_show (tool->yrange);
/* The curves graph */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (frame);
tool->graph = gimp_curve_view_new ();
gtk_widget_set_size_request (tool->graph,
GRAPH_SIZE + RADIUS * 2,
GRAPH_SIZE + RADIUS * 2);
g_object_set (tool->graph,
"border-width", RADIUS,
"subdivisions", 1,
NULL);
gimp_curve_view_set_curve (GIMP_CURVE_VIEW (tool->graph),
config->curve[config->channel]);
gtk_container_add (GTK_CONTAINER (frame), tool->graph);
gtk_widget_show (tool->graph);
gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options),
GIMP_HISTOGRAM_VIEW (tool->graph));
/* The bottom color bar */
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_table_attach (GTK_TABLE (table), hbox2, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hbox2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, TRUE, RADIUS);
gtk_widget_show (frame);
vbox = gtk_vbox_new (TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
tool->xrange = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_size_request (tool->xrange, -1, BAR_SIZE / 2);
gtk_box_pack_start (GTK_BOX (vbox), tool->xrange, TRUE, TRUE, 0);
gtk_widget_show (tool->xrange);
bar = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), bar, TRUE, TRUE, 0);
gtk_widget_show (bar);
gtk_widget_show (table);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_end (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Curve _type:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
tool->curve_type = combo = gimp_enum_combo_box_new (GIMP_TYPE_CURVE_TYPE);
gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (combo),
"gimp-curve");
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), 0,
G_CALLBACK (curves_curve_type_callback),
tool);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
}
GimpPDBStatusType
script_fu_interface (SFScript *script,
gint start_arg)
{
GtkWidget *dialog;
GtkWidget *menu;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkSizeGroup *group;
GSList *list;
gchar *title;
gint i;
static gboolean gtk_initted = FALSE;
/* Simply return if there is already an interface. This is an
* ugly workaround for the fact that we can not process two
* scripts at a time.
*/
if (sf_interface != NULL)
{
gchar *message =
g_strdup_printf ("%s\n\n%s",
_("Script-Fu cannot process two scripts "
"at the same time."),
_("You are already running the \"%s\" script."));
g_message (message, sf_interface->title);
g_free (message);
return GIMP_PDB_CANCEL;
}
g_return_val_if_fail (script != NULL, FALSE);
if (!gtk_initted)
{
INIT_I18N();
gimp_ui_init ("script-fu", TRUE);
gtk_initted = TRUE;
}
sf_status = GIMP_PDB_SUCCESS;
sf_interface = g_slice_new0 (SFInterface);
sf_interface->widgets = g_new0 (GtkWidget *, script->n_args);
sf_interface->title = script_fu_script_get_title (script);
title = g_strdup_printf (_("Script-Fu: %s"), sf_interface->title);
sf_interface->dialog = dialog =
gimp_dialog_new (title, "script-fu",
NULL, 0,
gimp_standard_help_func, script->name,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_free (title);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
g_signal_connect (dialog, "response",
G_CALLBACK (script_fu_response),
script);
g_signal_connect_swapped (dialog, "destroy",
G_CALLBACK (script_fu_interface_quit),
script);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
/* The argument table */
sf_interface->table = gtk_table_new (script->n_args - start_arg, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (sf_interface->table), 6);
gtk_table_set_row_spacings (GTK_TABLE (sf_interface->table), 6);
gtk_box_pack_start (GTK_BOX (vbox), sf_interface->table, FALSE, FALSE, 0);
gtk_widget_show (sf_interface->table);
group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
for (i = start_arg; i < script->n_args; i++)
{
GtkWidget *widget = NULL;
GtkObject *adj;
gchar *label_text;
gfloat label_yalign = 0.5;
gint *ID_ptr = NULL;
gint row = i;
gboolean left_align = FALSE;
SFArg *arg = &script->args[i];
row -= start_arg;
/* we add a colon after the label;
* some languages want an extra space here
*/
label_text = g_strdup_printf (_("%s:"), gettext (arg->label));
switch (arg->type)
{
case SF_IMAGE:
case SF_DRAWABLE:
case SF_LAYER:
case SF_CHANNEL:
case SF_VECTORS:
switch (arg->type)
{
case SF_IMAGE:
widget = gimp_image_combo_box_new (NULL, NULL);
ID_ptr = &arg->value.sfa_image;
break;
case SF_DRAWABLE:
widget = gimp_drawable_combo_box_new (NULL, NULL);
ID_ptr = &arg->value.sfa_drawable;
break;
case SF_LAYER:
widget = gimp_layer_combo_box_new (NULL, NULL);
ID_ptr = &arg->value.sfa_layer;
break;
case SF_CHANNEL:
widget = gimp_channel_combo_box_new (NULL, NULL);
ID_ptr = &arg->value.sfa_channel;
break;
case SF_VECTORS:
widget = gimp_vectors_combo_box_new (NULL, NULL);
ID_ptr = &arg->value.sfa_vectors;
break;
default:
menu = NULL;
break;
}
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (widget), *ID_ptr,
G_CALLBACK (gimp_int_combo_box_get_active),
ID_ptr);
break;
case SF_COLOR:
left_align = TRUE;
widget = gimp_color_button_new (_("Script-Fu Color Selection"),
COLOR_SAMPLE_WIDTH,
COLOR_SAMPLE_HEIGHT,
&arg->value.sfa_color,
GIMP_COLOR_AREA_FLAT);
gimp_color_button_set_update (GIMP_COLOR_BUTTON (widget), TRUE);
g_signal_connect (widget, "color-changed",
G_CALLBACK (gimp_color_button_get_color),
&arg->value.sfa_color);
break;
case SF_TOGGLE:
g_free (label_text);
label_text = NULL;
widget = gtk_check_button_new_with_mnemonic (gettext (arg->label));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
arg->value.sfa_toggle);
g_signal_connect (widget, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&arg->value.sfa_toggle);
break;
case SF_VALUE:
case SF_STRING:
widget = gtk_entry_new ();
gtk_widget_set_size_request (widget, TEXT_WIDTH, -1);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
gtk_entry_set_text (GTK_ENTRY (widget), arg->value.sfa_value);
break;
case SF_TEXT:
{
GtkWidget *view;
GtkTextBuffer *buffer;
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (widget, TEXT_WIDTH, -1);
view = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (widget), view);
gtk_widget_show (view);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_view_set_editable (GTK_TEXT_VIEW (view), TRUE);
gtk_text_buffer_set_text (buffer, arg->value.sfa_value, -1);
label_yalign = 0.0;
}
break;
case SF_ADJUSTMENT:
switch (arg->default_value.sfa_adjustment.type)
{
case SF_SLIDER:
arg->value.sfa_adjustment.adj = (GtkAdjustment *)
gimp_scale_entry_new (GTK_TABLE (sf_interface->table),
0, row,
label_text, SLIDER_WIDTH, -1,
arg->value.sfa_adjustment.value,
arg->default_value.sfa_adjustment.lower,
arg->default_value.sfa_adjustment.upper,
arg->default_value.sfa_adjustment.step,
arg->default_value.sfa_adjustment.page,
arg->default_value.sfa_adjustment.digits,
TRUE, 0.0, 0.0,
NULL, NULL);
gtk_entry_set_activates_default (GIMP_SCALE_ENTRY_SPINBUTTON (arg->value.sfa_adjustment.adj), TRUE);
break;
default:
g_warning ("unexpected adjustment type: %d",
arg->default_value.sfa_adjustment.type);
/* fallthrough */
case SF_SPINNER:
left_align = TRUE;
widget =
gimp_spin_button_new (&adj,
arg->value.sfa_adjustment.value,
arg->default_value.sfa_adjustment.lower,
arg->default_value.sfa_adjustment.upper,
arg->default_value.sfa_adjustment.step,
arg->default_value.sfa_adjustment.page,
0, 0,
arg->default_value.sfa_adjustment.digits);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
arg->value.sfa_adjustment.adj = GTK_ADJUSTMENT (adj);
break;
}
g_signal_connect (arg->value.sfa_adjustment.adj,
"value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&arg->value.sfa_adjustment.value);
break;
case SF_FILENAME:
case SF_DIRNAME:
if (arg->type == SF_FILENAME)
widget = gtk_file_chooser_button_new (_("Script-Fu File Selection"),
GTK_FILE_CHOOSER_ACTION_OPEN);
else
widget = gtk_file_chooser_button_new (_("Script-Fu Folder Selection"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if (arg->value.sfa_file.filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget),
arg->value.sfa_file.filename);
g_signal_connect (widget, "selection-changed",
G_CALLBACK (script_fu_file_callback),
&arg->value.sfa_file);
break;
case SF_FONT:
widget = gimp_font_select_button_new (_("Script-Fu Font Selection"),
arg->value.sfa_font);
g_signal_connect_swapped (widget, "font-set",
G_CALLBACK (script_fu_font_callback),
&arg->value.sfa_font);
break;
case SF_PALETTE:
widget = gimp_palette_select_button_new (_("Script-Fu Palette Selection"),
arg->value.sfa_palette);
g_signal_connect_swapped (widget, "palette-set",
G_CALLBACK (script_fu_palette_callback),
&arg->value.sfa_palette);
break;
case SF_PATTERN:
left_align = TRUE;
widget = gimp_pattern_select_button_new (_("Script-Fu Pattern Selection"),
arg->value.sfa_pattern);
g_signal_connect_swapped (widget, "pattern-set",
G_CALLBACK (script_fu_pattern_callback),
&arg->value.sfa_pattern);
break;
case SF_GRADIENT:
left_align = TRUE;
widget = gimp_gradient_select_button_new (_("Script-Fu Gradient Selection"),
arg->value.sfa_gradient);
g_signal_connect_swapped (widget, "gradient-set",
G_CALLBACK (script_fu_gradient_callback),
&arg->value.sfa_gradient);
break;
case SF_BRUSH:
left_align = TRUE;
widget = gimp_brush_select_button_new (_("Script-Fu Brush Selection"),
arg->value.sfa_brush.name,
arg->value.sfa_brush.opacity,
arg->value.sfa_brush.spacing,
arg->value.sfa_brush.paint_mode);
g_signal_connect_swapped (widget, "brush-set",
G_CALLBACK (script_fu_brush_callback),
&arg->value.sfa_brush);
break;
case SF_OPTION:
#if GTK_CHECK_VERSION (2, 24, 0)
widget = gtk_combo_box_text_new ();
#else
widget = gtk_combo_box_new_text ();
#endif
for (list = arg->default_value.sfa_option.list;
list;
list = g_slist_next (list))
{
#if GTK_CHECK_VERSION (2, 24, 0)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget),
gettext (list->data));
#else
gtk_combo_box_append_text (GTK_COMBO_BOX (widget),
gettext (list->data));
#endif
}
gtk_combo_box_set_active (GTK_COMBO_BOX (widget),
arg->value.sfa_option.history);
g_signal_connect (widget, "changed",
G_CALLBACK (script_fu_combo_callback),
&arg->value.sfa_option);
break;
case SF_ENUM:
widget = gimp_enum_combo_box_new (g_type_from_name (arg->default_value.sfa_enum.type_name));
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (widget),
arg->value.sfa_enum.history);
g_signal_connect (widget, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&arg->value.sfa_enum.history);
break;
case SF_DISPLAY:
break;
}
if (widget)
{
if (label_text)
{
gimp_table_attach_aligned (GTK_TABLE (sf_interface->table),
0, row,
label_text, 0.0, label_yalign,
widget, 2, left_align);
g_free (label_text);
}
else
{
gtk_table_attach (GTK_TABLE (sf_interface->table),
widget, 0, 3, row, row + 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (widget);
}
if (left_align)
gtk_size_group_add_widget (group, widget);
}
sf_interface->widgets[i] = widget;
}
g_object_unref (group);
/* the script progress bar */
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_box_pack_end (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
gtk_widget_show (vbox2);
sf_interface->progress_bar = gimp_progress_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox2), sf_interface->progress_bar,
FALSE, FALSE, 0);
gtk_widget_show (sf_interface->progress_bar);
sf_interface->progress_label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (sf_interface->progress_label), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (sf_interface->progress_label),
PANGO_ELLIPSIZE_MIDDLE);
gimp_label_set_attributes (GTK_LABEL (sf_interface->progress_label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), sf_interface->progress_label,
FALSE, FALSE, 0);
gtk_widget_show (sf_interface->progress_label);
gtk_widget_show (dialog);
gtk_main ();
return sf_status;
}
GtkWidget *
convert_dialog_new (GimpImage *image,
GimpContext *context,
GtkWidget *parent,
GimpProgress *progress)
{
IndexedDialog *dialog;
GtkWidget *button;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *spinbutton;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *palette_box;
GtkWidget *combo;
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 (IndexedDialog);
dialog->image = image;
dialog->progress = progress;
dialog->dither_type = saved_dither_type;
dialog->alpha_dither = saved_alpha_dither;
dialog->remove_dups = saved_remove_dups;
dialog->num_colors = saved_num_colors;
dialog->palette_type = saved_palette_type;
dialog->dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
_("Indexed Color Conversion"),
"gimp-image-convert-indexed",
GIMP_STOCK_CONVERT_INDEXED,
_("Convert Image to Indexed Colors"),
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_CONVERT_INDEXED,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog),
_("C_onvert"), GTK_RESPONSE_OK);
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_stock (GIMP_STOCK_CONVERT_INDEXED,
GTK_ICON_SIZE_BUTTON));
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) convert_dialog_free, dialog);
g_signal_connect (dialog->dialog, "response",
G_CALLBACK (convert_dialog_response),
dialog);
palette_box = convert_dialog_palette_box (dialog);
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog->dialog)->vbox),
main_vbox);
gtk_widget_show (main_vbox);
/* palette */
frame =
gimp_enum_radio_frame_new_with_range (GIMP_TYPE_CONVERT_PALETTE_TYPE,
GIMP_MAKE_PALETTE,
(palette_box ?
GIMP_CUSTOM_PALETTE :
GIMP_MONO_PALETTE),
gtk_label_new (_("Colormap")),
G_CALLBACK (gimp_radio_button_update),
&dialog->palette_type,
&button);
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button),
dialog->palette_type);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* max n_colors */
hbox = gtk_hbox_new (FALSE, 6);
gimp_enum_radio_frame_add (GTK_FRAME (frame), hbox, GIMP_MAKE_PALETTE);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("_Maximum number of colors:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
if (dialog->num_colors == 256 && gimp_image_has_alpha (image))
dialog->num_colors = 255;
spinbutton = gimp_spin_button_new (&adjustment, dialog->num_colors,
2, 256, 1, 8, 0, 1, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
g_signal_connect (adjustment, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&dialog->num_colors);
/* custom palette */
if (palette_box)
{
gimp_enum_radio_frame_add (GTK_FRAME (frame),
palette_box, GIMP_CUSTOM_PALETTE);
gtk_widget_show (palette_box);
}
vbox = gtk_bin_get_child (GTK_BIN (frame));
toggle = gtk_check_button_new_with_mnemonic (_("_Remove unused colors "
"from colormap"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
dialog->remove_dups);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 3);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&dialog->remove_dups);
g_object_set_data (G_OBJECT (button), "inverse_sensitive", toggle);
gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (button));
/* dithering */
frame = gimp_frame_new (_("Dithering"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Color _dithering:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_enum_combo_box_new (GIMP_TYPE_CONVERT_DITHER_TYPE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
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->dither_type,
G_CALLBACK (gimp_int_combo_box_get_active),
&dialog->dither_type);
toggle =
gtk_check_button_new_with_mnemonic (_("Enable dithering of _transparency"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
dialog->alpha_dither);
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->alpha_dither);
return dialog->dialog;
}
static GtkWidget *
gimp_align_tool_controls (GimpAlignTool *align_tool)
{
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *button;
GtkWidget *spinbutton;
GtkWidget *combo;
gint n = 0;
main_vbox = gtk_vbox_new (FALSE, 12);
frame = gimp_frame_new (_("Align"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
frame = gimp_frame_new (_("Relative to:"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
combo = gimp_enum_combo_box_new (GIMP_TYPE_ALIGN_REFERENCE);
gtk_container_add (GTK_CONTAINER (frame), combo);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
GIMP_ALIGN_REFERENCE_FIRST,
G_CALLBACK (gimp_int_combo_box_get_active),
&align_tool->align_reference_type);
gtk_widget_show (combo);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = button_with_stock (GIMP_ALIGN_LEFT, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Align left edge of target"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ALIGN_HCENTER, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Align center of target"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ALIGN_RIGHT, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Align right edge of target"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = button_with_stock (GIMP_ALIGN_TOP, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Align top edge of target"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ALIGN_VCENTER, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Align middle of target"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ALIGN_BOTTOM, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Align bottom of target"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
frame = gimp_frame_new (_("Distribute"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = button_with_stock (GIMP_ARRANGE_LEFT, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Distribute left edges of targets"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ARRANGE_HCENTER, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button,
_("Distribute horizontal centers of targets"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ARRANGE_RIGHT, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button,
_("Distribute right edges of targets"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = button_with_stock (GIMP_ARRANGE_TOP, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Distribute top edges of targets"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ARRANGE_VCENTER, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button,
_("Distribute vertical centers of targets"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = button_with_stock (GIMP_ARRANGE_BOTTOM, align_tool);
align_tool->button[n++] = button;
gimp_help_set_help_data (button, _("Distribute bottoms of targets"), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Offset:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
spinbutton = gimp_spin_button_new (&align_tool->horz_offset_adjustment,
0,
-100000.,
100000.,
1., 20., 20., 1., 0);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
g_signal_connect (align_tool->horz_offset_adjustment, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&align_tool->horz_offset);
gtk_widget_show (spinbutton);
return main_vbox;
}