static WidgetInfo *
create_int_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_int_combo_box_new ("Sobel", 1,
"Prewitt", 2,
"Gradient", 3,
"Roberts", 4,
"Differential", 5,
"Laplace", 6,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), 1);
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 ("Int Combo Box"), FALSE, FALSE, 0);
return new_widget_info ("gimp-widget-int-combo-box", vbox, SMALL);
}
static void
load_gui_defaults (JpegSaveGui *pg)
{
GtkAdjustment *restart_markers;
load_defaults ();
#define SET_ACTIVE_BTTN(field) \
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pg->field), jsvals.field)
SET_ACTIVE_BTTN (optimize);
SET_ACTIVE_BTTN (progressive);
SET_ACTIVE_BTTN (use_orig_quality);
SET_ACTIVE_BTTN (preview);
SET_ACTIVE_BTTN (save_exif);
SET_ACTIVE_BTTN (save_thumbnail);
SET_ACTIVE_BTTN (save_xmp);
SET_ACTIVE_BTTN (save_iptc);
#undef SET_ACTIVE_BTTN
/*spin button stuff*/
g_signal_handler_block (pg->use_restart_markers, pg->handler_id_restart);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pg->use_restart_markers),
jsvals.restart);
restart_markers = GTK_ADJUSTMENT (pg->scale_data);
gtk_adjustment_set_value (restart_markers, jsvals.restart);
g_signal_handler_unblock (pg->use_restart_markers, pg->handler_id_restart);
gtk_adjustment_set_value (GTK_ADJUSTMENT (pg->quality),
jsvals.quality);
gtk_adjustment_set_value (GTK_ADJUSTMENT (pg->smoothing),
jsvals.smoothing);
if (gimp_drawable_is_rgb (drawable_ID_global))
{
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (pg->subsmp),
jsvals.subsmp);
}
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (pg->dct),
jsvals.dct);
}
static void
use_orig_qual_changed2 (GtkWidget *toggle,
GtkWidget *combo)
{
/* the test is (orig_quality > 0), not (orig_subsmp > 0) - this is normal */
if (jsvals.use_orig_quality && orig_quality > 0)
{
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), orig_subsmp);
}
}
/**
* gimp_color_frame_set_mode:
* @frame: The #GimpColorFrame.
* @mode: The new @mode.
*
* Sets the #GimpColorFrame's color @mode. Calling this function does
* the same as selecting the @mode from the frame's #GtkOptionMenu.
**/
void
gimp_color_frame_set_mode (GimpColorFrame *frame,
GimpColorFrameMode mode)
{
g_return_if_fail (GIMP_IS_COLOR_FRAME (frame));
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (frame->menu), mode);
g_object_notify (G_OBJECT (frame), "mode");
}
static gboolean
gimp_levels_tool_initialize (GimpTool *tool,
GimpDisplay *display,
GError **error)
{
GimpLevelsTool *l_tool = GIMP_LEVELS_TOOL (tool);
GimpDrawable *drawable = gimp_image_get_active_drawable (display->image);
if (! drawable)
return FALSE;
if (gimp_drawable_is_indexed (drawable))
{
g_set_error (error, 0, 0,
_("Levels does not operate on indexed layers."));
return FALSE;
}
if (! l_tool->hist)
l_tool->hist = gimp_histogram_new ();
levels_init (l_tool->levels);
l_tool->channel = GIMP_HISTOGRAM_VALUE;
l_tool->color = gimp_drawable_is_rgb (drawable);
l_tool->alpha = gimp_drawable_has_alpha (drawable);
if (l_tool->active_picker)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l_tool->active_picker),
FALSE);
GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error);
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (l_tool->channel_menu),
levels_menu_sensitivity, l_tool, NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (l_tool->channel_menu),
l_tool->channel);
/* FIXME: hack */
if (! l_tool->color)
l_tool->channel = (l_tool->channel == GIMP_HISTOGRAM_ALPHA) ? 1 : 0;
levels_update (l_tool, ALL);
gimp_drawable_calculate_histogram (drawable, l_tool->hist);
gimp_histogram_view_set_histogram (GIMP_HISTOGRAM_VIEW (l_tool->hist_view),
l_tool->hist);
return TRUE;
}
static void
cm_update_ui (CmParamsType *mix)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle),
mix->monochrome);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->preserve_luminosity_toggle),
mix->preserve_luminosity);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo),
mix->output_channel);
cm_set_adjusters (mix);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
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_brush_select_mode_changed (GimpContext *context,
GimpLayerModeEffects paint_mode,
GimpBrushSelect *select)
{
g_signal_handlers_block_by_func (select->paint_mode_menu,
gimp_brush_select_mode_update,
select);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (select->paint_mode_menu),
paint_mode);
g_signal_handlers_unblock_by_func (select->paint_mode_menu,
gimp_brush_select_mode_update,
select);
gimp_pdb_dialog_run_callback (GIMP_PDB_DIALOG (select), FALSE);
}
/*
* gfig_style_set_content_from_style() sets all of the style control widgets
* to values from the specified style. This in turn sets the Gimp core's
* values to the same things. Repainting is suppressed while this happens,
* so calling this function will not produce a repaint.
*
*/
void
gfig_style_set_context_from_style (Style *style)
{
gboolean enable_repaint;
if (gfig_context->debug_styles)
g_printerr ("Setting context from style '%s' -- ", style->name);
enable_repaint = gfig_context->enable_repaint;
gfig_context->enable_repaint = FALSE;
gimp_color_button_set_color (GIMP_COLOR_BUTTON (gfig_context->fg_color_button),
&style->foreground);
gimp_color_button_set_color (GIMP_COLOR_BUTTON (gfig_context->bg_color_button),
&style->background);
if (!gimp_context_set_brush (style->brush_name))
g_message ("Style from context: Failed to set brush to '%s'",
style->brush_name);
gimp_brush_select_button_set_brush (GIMP_BRUSH_SELECT_BUTTON (gfig_context->brush_select),
style->brush_name, -1.0, -1, -1); /* FIXME */
gimp_pattern_select_button_set_pattern (GIMP_PATTERN_SELECT_BUTTON (gfig_context->pattern_select),
style->pattern);
gimp_gradient_select_button_set_gradient (GIMP_GRADIENT_SELECT_BUTTON (gfig_context->gradient_select),
style->gradient);
gfig_context->bdesc.name = style->brush_name;
if (gfig_context->debug_styles)
g_printerr ("done.\n");
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (gfig_context->fillstyle_combo),
(gint) style->fill_type);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gfig_context->paint_type_toggle),
style->paint_type);
gfig_context->enable_repaint = enable_repaint;
}
static void
print_size_info_center_none (void)
{
/* return early if we are called from a unit change */
if (gimp_size_entry_get_unit (info.size_entry) != info.data->unit)
return;
info.data->center = CENTER_NONE;
if (info.center_combo)
{
g_signal_handlers_block_by_func (info.center_combo,
print_size_info_center_changed, NULL);
info.data->center = CENTER_NONE;
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (info.center_combo),
info.data->center);
g_signal_handlers_unblock_by_func (info.center_combo,
print_size_info_center_changed, NULL);
}
}
static void
gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool);
GimpLevelsConfig *config = tool->config;
GtkListStore *store;
GtkSizeGroup *label_group;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *vbox3;
GtkWidget *hbox;
GtkWidget *hbox2;
GtkWidget *label;
GtkWidget *menu;
GtkWidget *frame;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *spinbutton;
GtkAdjustment *adjustment;
GtkWidget *bar;
GtkWidget *handle_bar;
gint border;
g_signal_connect (image_map_tool->settings_box, "file-dialog-setup",
G_CALLBACK (gimp_levels_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 option menu for selecting channels */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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);
menu = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store));
g_object_unref (store);
g_signal_connect (menu, "changed",
G_CALLBACK (levels_channel_callback),
tool);
gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (menu),
"gimp-channel");
gtk_box_pack_start (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
tool->channel_menu = menu;
gtk_label_set_mnemonic_widget (GTK_LABEL (label), 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 (levels_channel_reset_callback),
tool);
menu = gimp_prop_enum_stock_box_new (G_OBJECT (tool_options),
"histogram-scale", "gimp-histogram",
0, 0);
gtk_box_pack_end (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
/* Input levels frame */
frame = gimp_frame_new (_("Input Levels"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
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, 0);
gtk_widget_show (frame);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
gtk_widget_show (vbox2);
tool->histogram_view = gimp_histogram_view_new (FALSE);
gtk_box_pack_start (GTK_BOX (vbox2), tool->histogram_view, TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET (tool->histogram_view));
gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options),
GIMP_HISTOGRAM_VIEW (tool->histogram_view));
g_object_get (tool->histogram_view, "border-width", &border, NULL);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox3), border);
gtk_box_pack_start (GTK_BOX (vbox2), vbox3, FALSE, FALSE, 0);
gtk_widget_show (vbox3);
tool->input_bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL);
gtk_widget_set_size_request (tool->input_bar, -1, GRADIENT_HEIGHT / 2);
gtk_box_pack_start (GTK_BOX (vbox3), tool->input_bar, FALSE, FALSE, 0);
gtk_widget_show (tool->input_bar);
bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL);
gtk_widget_set_size_request (bar, -1, GRADIENT_HEIGHT / 2);
gtk_box_pack_start (GTK_BOX (vbox3), bar, FALSE, FALSE, 0);
gtk_widget_show (bar);
handle_bar = g_object_new (GIMP_TYPE_HANDLE_BAR, NULL);
gtk_widget_set_size_request (handle_bar, -1, CONTROL_HEIGHT);
gtk_box_pack_start (GTK_BOX (vbox3), handle_bar, FALSE, FALSE, 0);
gtk_widget_show (handle_bar);
gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar),
tool->input_bar);
gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar),
bar);
/* Horizontal box for input levels spinbuttons */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* low input spin */
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
gtk_widget_show (hbox2);
button = gimp_levels_tool_color_picker_new (tool, PICK_LOW_INPUT);
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
tool->low_input_spinbutton = spinbutton =
gimp_prop_spin_button_new (image_map_tool->config, "low-input",
0.01, 0.1, 1);
gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
tool->low_input = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton));
gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 0,
tool->low_input);
/* input gamma spin */
spinbutton = gimp_prop_spin_button_new (image_map_tool->config, "gamma",
0.01, 0.1, 2);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, FALSE, 0);
gimp_help_set_help_data (spinbutton, _("Gamma"), NULL);
gtk_widget_show (spinbutton);
tool->gamma = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton));
tool->gamma_linear = GTK_ADJUSTMENT (gtk_adjustment_new (127, 0, 255,
0.1, 1.0, 0.0));
g_signal_connect (tool->gamma_linear, "value-changed",
G_CALLBACK (levels_linear_gamma_changed),
tool);
gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 1,
tool->gamma_linear);
g_object_unref (tool->gamma_linear);
/* high input spin */
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
gtk_widget_show (hbox2);
button = gimp_levels_tool_color_picker_new (tool, PICK_HIGH_INPUT);
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);
gtk_widget_show (button);
spinbutton = gimp_prop_spin_button_new (image_map_tool->config, "high-input",
0.01, 0.1, 1);
gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
tool->high_input_spinbutton = spinbutton;
tool->high_input = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton));
gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 2,
tool->high_input);
/* Output levels frame */
frame = gimp_frame_new (_("Output Levels"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
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, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), border);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
gtk_widget_show (vbox2);
tool->output_bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL);
gtk_widget_set_size_request (tool->output_bar, -1, GRADIENT_HEIGHT);
gtk_box_pack_start (GTK_BOX (vbox2), tool->output_bar, FALSE, FALSE, 0);
gtk_widget_show (tool->output_bar);
handle_bar = g_object_new (GIMP_TYPE_HANDLE_BAR, NULL);
gtk_widget_set_size_request (handle_bar, -1, CONTROL_HEIGHT);
gtk_box_pack_start (GTK_BOX (vbox2), handle_bar, FALSE, FALSE, 0);
gtk_widget_show (handle_bar);
gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar),
tool->output_bar);
/* Horizontal box for levels spin widgets */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* low output spin */
tool->low_output_spinbutton = spinbutton =
gimp_prop_spin_button_new (image_map_tool->config, "low-output",
0.01, 0.1, 1);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton));
gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 0, adjustment);
/* high output spin */
tool->high_output_spinbutton = spinbutton =
gimp_prop_spin_button_new (image_map_tool->config, "high-output",
0.01, 0.1, 1);
gtk_box_pack_end (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton));
gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 2, adjustment);
/* all channels frame */
frame = gimp_frame_new (_("All Channels"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
hbbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_mnemonic (_("_Auto"));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gimp_help_set_help_data (button, _("Adjust levels automatically"), NULL);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (levels_stretch_callback),
tool);
button = gimp_levels_tool_color_picker_new (tool,
PICK_LOW_INPUT | PICK_ALL_CHANNELS);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = gimp_levels_tool_color_picker_new (tool,
PICK_GAMMA | PICK_ALL_CHANNELS);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = gimp_levels_tool_color_picker_new (tool,
PICK_HIGH_INPUT | PICK_ALL_CHANNELS);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = gimp_stock_button_new (GIMP_STOCK_TOOL_CURVES,
_("Edit these Settings as Curves"));
gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (levels_to_curves_callback),
tool);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu),
config->channel);
}
gboolean
save_dialog (void)
{
JpegSaveGui pg;
GtkWidget *dialog;
GtkWidget *vbox;
GtkObject *entry;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *tabledefaults;
GtkWidget *expander;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *spinbutton;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
GtkWidget *scrolled_window;
GtkWidget *button;
gchar *text;
gint row;
dialog = gimp_export_dialog_new (_("JPEG"), PLUG_IN_BINARY, SAVE_PROC);
g_signal_connect (dialog, "response",
G_CALLBACK (save_dialog_response),
&pg);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
pg.quality = entry = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Quality:"),
SCALE_WIDTH, 0, jsvals.quality,
0.0, 100.0, 1.0, 10.0, 0,
TRUE, 0.0, 0.0,
_("JPEG quality parameter"),
"file-jpeg-save-quality");
g_signal_connect (entry, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&jsvals.quality);
g_signal_connect (entry, "value-changed",
G_CALLBACK (make_preview),
NULL);
preview_size = gtk_label_new (_("File size: unknown"));
gtk_misc_set_alignment (GTK_MISC (preview_size), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (preview_size), PANGO_ELLIPSIZE_END);
gimp_label_set_attributes (GTK_LABEL (preview_size),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox), preview_size, FALSE, FALSE, 0);
gtk_widget_show (preview_size);
gimp_help_set_help_data (preview_size,
_("Enable preview to obtain the file size."), NULL);
pg.preview = toggle =
gtk_check_button_new_with_mnemonic (_("Sho_w preview in image window"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.preview);
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),
&jsvals.preview);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
text = g_strdup_printf ("<b>%s</b>", _("_Advanced Options"));
expander = gtk_expander_new_with_mnemonic (text);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
g_free (text);
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 0);
gtk_widget_show (expander);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_add (GTK_CONTAINER (expander), vbox);
gtk_widget_show (vbox);
frame = gimp_frame_new ("<expander>");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (4, 8, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12);
gtk_container_add (GTK_CONTAINER (frame), table);
table2 = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table2), 6);
gtk_table_attach (GTK_TABLE (table), table2,
2, 6, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (table2);
pg.smoothing = entry = gimp_scale_entry_new (GTK_TABLE (table2), 0, 0,
_("S_moothing:"),
100, 0, jsvals.smoothing,
0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0.0, 0.0,
NULL,
"file-jpeg-save-smoothing");
g_signal_connect (entry, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&jsvals.smoothing);
g_signal_connect (entry, "value-changed",
G_CALLBACK (make_preview),
NULL);
restart_markers_label = gtk_label_new (_("Interval (MCU rows):"));
gtk_misc_set_alignment (GTK_MISC (restart_markers_label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), restart_markers_label, 4, 5, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (restart_markers_label);
pg.scale_data = (GtkAdjustment *)
gtk_adjustment_new (((jsvals.restart == 0) ?
DEFAULT_RESTART_MCU_ROWS : jsvals.restart),
1.0, 64.0, 1.0, 1.0, 0);
pg.restart = restart_markers_scale = spinbutton =
gtk_spin_button_new (pg.scale_data, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_table_attach (GTK_TABLE (table), spinbutton, 5, 6, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (spinbutton);
pg.use_restart_markers = toggle =
gtk_check_button_new_with_mnemonic (_("Use _restart markers"));
gtk_table_attach (GTK_TABLE (table), toggle, 2, 4, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.restart);
gtk_widget_set_sensitive (restart_markers_label, jsvals.restart);
gtk_widget_set_sensitive (restart_markers_scale, jsvals.restart);
g_signal_connect (pg.scale_data, "value-changed",
G_CALLBACK (save_restart_update),
toggle);
pg.handler_id_restart = g_signal_connect_swapped (toggle, "toggled",
G_CALLBACK (save_restart_update),
pg.scale_data);
row = 0;
/* Optimize */
pg.optimize = toggle = gtk_check_button_new_with_mnemonic (_("_Optimize"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.optimize);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.optimize);
if (arithc_supported)
gtk_widget_set_sensitive (toggle, !jsvals.arithmetic_coding);
row++;
if (arithc_supported)
{
/* Arithmetic coding */
pg.arithmetic_coding = toggle = gtk_check_button_new_with_mnemonic
(_("Use arithmetic _coding"));
gtk_widget_set_tooltip_text
(toggle, _("Older software may have trouble opening "
"arithmetic-coded images"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.arithmetic_coding);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (toggle_arithmetic_coding),
pg.optimize);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.arithmetic_coding);
row++;
}
/* Progressive */
pg.progressive = toggle =
gtk_check_button_new_with_mnemonic (_("_Progressive"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.progressive);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.progressive);
row++;
/* Save EXIF data */
pg.save_exif = toggle =
gtk_check_button_new_with_mnemonic (_("Save _Exif data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_exif);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_exif);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* Save thumbnail */
pg.save_thumbnail = toggle =
gtk_check_button_new_with_mnemonic (_("Save _thumbnail"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_thumbnail);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_thumbnail);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
row++;
/* XMP metadata */
pg.save_xmp = toggle =
gtk_check_button_new_with_mnemonic (_("Save _XMP data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_xmp);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_xmp);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* IPTC metadata */
pg.save_iptc = toggle =
gtk_check_button_new_with_mnemonic (_("Save _IPTC data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_iptc);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_iptc);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* custom quantization tables - now used also for original quality */
pg.use_orig_quality = toggle =
gtk_check_button_new_with_mnemonic (_("_Use quality settings from original "
"image"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 4,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("If the original image was loaded from a JPEG "
"file using non-standard quality settings "
"(quantization tables), enable this option to "
"get almost the same quality and file size."),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.use_orig_quality);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.use_orig_quality
&& (orig_quality > 0));
gtk_widget_set_sensitive (toggle, (orig_quality > 0));
/* changing quality disables custom quantization tables, and vice-versa */
g_signal_connect (pg.quality, "value-changed",
G_CALLBACK (quality_changed),
pg.use_orig_quality);
g_signal_connect (pg.use_orig_quality, "toggled",
G_CALLBACK (use_orig_qual_changed),
pg.quality);
/* Subsampling */
label = gtk_label_new_with_mnemonic (_("Su_bsampling:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
pg.subsmp =
combo = gimp_int_combo_box_new (_("4:4:4 (best quality)"),
JPEG_SUBSAMPLING_1x1_1x1_1x1,
_("4:2:2 horizontal (chroma halved)"),
JPEG_SUBSAMPLING_2x1_1x1_1x1,
_("4:2:2 vertical (chroma halved)"),
JPEG_SUBSAMPLING_1x2_1x1_1x1,
_("4:2:0 (chroma quartered)"),
JPEG_SUBSAMPLING_2x2_1x1_1x1,
NULL);
gtk_table_attach (GTK_TABLE (table), combo, 3, 6, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
if (gimp_drawable_is_rgb (drawable_ID_global))
{
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
jsvals.subsmp,
G_CALLBACK (subsampling_changed),
entry);
g_signal_connect (pg.use_orig_quality, "toggled",
G_CALLBACK (use_orig_qual_changed2),
pg.subsmp);
}
else
{
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
JPEG_SUBSAMPLING_1x1_1x1_1x1);
gtk_widget_set_sensitive (combo, FALSE);
}
/* DCT method */
label = gtk_label_new_with_mnemonic (_("_DCT method:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
pg.dct = combo = gimp_int_combo_box_new (_("Fast Integer"), 1,
_("Integer"), 0,
_("Floating-Point"), 2,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), jsvals.dct);
gtk_table_attach (GTK_TABLE (table), combo, 3, 6, 3, 4,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&jsvals.dct);
g_signal_connect (combo, "changed",
G_CALLBACK (make_preview),
NULL);
frame = gimp_frame_new (_("Comment"));
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled_window, 250, 50);
gtk_container_add (GTK_CONTAINER (frame), scrolled_window);
gtk_widget_show (scrolled_window);
pg.text_buffer = text_buffer = gtk_text_buffer_new (NULL);
if (image_comment)
gtk_text_buffer_set_text (text_buffer, image_comment, -1);
text_view = gtk_text_view_new_with_buffer (text_buffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_widget_show (text_view);
g_object_unref (text_buffer);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
tabledefaults = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (tabledefaults), 6);
gtk_box_pack_start (GTK_BOX (vbox), tabledefaults, FALSE, FALSE, 0);
gtk_widget_show (tabledefaults);
button = gtk_button_new_with_mnemonic (_("_Load Defaults"));
gtk_table_attach (GTK_TABLE (tabledefaults),
button, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (load_gui_defaults),
&pg);
button = gtk_button_new_with_mnemonic (_("Sa_ve Defaults"));
gtk_table_attach (GTK_TABLE (tabledefaults),
button, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (save_defaults),
&pg);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dialog);
make_preview ();
pg.run = FALSE;
gtk_main ();
destroy_preview ();
return pg.run;
}
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);
}
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 void
script_fu_reset (SFScript *script)
{
gint i;
script_fu_script_reset (script, FALSE);
for (i = 0; i < script->n_args; i++)
{
SFArgValue *value = &script->args[i].value;
GtkWidget *widget = sf_interface->widgets[i];
switch (script->args[i].type)
{
case SF_IMAGE:
case SF_DRAWABLE:
case SF_LAYER:
case SF_CHANNEL:
case SF_VECTORS:
case SF_DISPLAY:
break;
case SF_COLOR:
gimp_color_button_set_color (GIMP_COLOR_BUTTON (widget),
&value->sfa_color);
break;
case SF_TOGGLE:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
value->sfa_toggle);
break;
case SF_VALUE:
case SF_STRING:
gtk_entry_set_text (GTK_ENTRY (widget), value->sfa_value);
break;
case SF_TEXT:
{
GtkWidget *view;
GtkTextBuffer *buffer;
view = gtk_bin_get_child (GTK_BIN (widget));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_set_text (buffer, value->sfa_value, -1);
}
break;
case SF_ADJUSTMENT:
gtk_adjustment_set_value (value->sfa_adjustment.adj,
value->sfa_adjustment.value);
break;
case SF_FILENAME:
case SF_DIRNAME:
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget),
value->sfa_file.filename);
break;
case SF_FONT:
gimp_font_select_button_set_font (GIMP_FONT_SELECT_BUTTON (widget),
value->sfa_font);
break;
case SF_PALETTE:
gimp_palette_select_button_set_palette (GIMP_PALETTE_SELECT_BUTTON (widget),
value->sfa_palette);
break;
case SF_PATTERN:
gimp_pattern_select_button_set_pattern (GIMP_PATTERN_SELECT_BUTTON (widget),
value->sfa_pattern);
break;
case SF_GRADIENT:
gimp_gradient_select_button_set_gradient (GIMP_GRADIENT_SELECT_BUTTON (widget),
value->sfa_gradient);
break;
case SF_BRUSH:
gimp_brush_select_button_set_brush (GIMP_BRUSH_SELECT_BUTTON (widget),
value->sfa_brush.name,
value->sfa_brush.opacity,
value->sfa_brush.spacing,
value->sfa_brush.paint_mode);
break;
case SF_OPTION:
gtk_combo_box_set_active (GTK_COMBO_BOX (widget),
value->sfa_option.history);
break;
case SF_ENUM:
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (widget),
value->sfa_enum.history);
break;
}
}
}
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;
}
static gboolean
file_vtf_save_dialog (SaveInfo *info)
{
gimp_ui_init ("file-vtf", TRUE);
GtkWidget *dialog = gimp_export_dialog_new ("Valve Texture",
"file-vtf", "plug-in-vtf");
GtkWidget *table = gtk_table_new (2, 2, FALSE);
g_object_set (G_OBJECT (table),
"border-width", 12,
"column-spacing", 8,
"row-spacing", 4,
NULL);
info->ctl_version = gimp_int_combo_box_new (
"7.0", 0,
"7.2", 2,
"7.3", 3,
"7.4", 4,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (info->ctl_version), info->version);
g_signal_connect (info->ctl_version, "changed",
G_CALLBACK (save_dialog_version_changed), info);
gtk_table_attach (GTK_TABLE (table), info->ctl_version, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
GtkWidget *label = gtk_label_new ("_Version:");
g_object_set (G_OBJECT (label),
"mnemonic-widget", info->ctl_version,
"use-underline", TRUE,
"xalign", 1.0,
NULL);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
info->ctl_format = gimp_int_combo_box_new (
Vtf::formatToString (Vtf::FormatRGBA8888), Vtf::FormatRGBA8888,
Vtf::formatToString (Vtf::FormatDXT1), Vtf::FormatDXT1,
Vtf::formatToString (Vtf::FormatDXT3), Vtf::FormatDXT3,
Vtf::formatToString (Vtf::FormatDXT5), Vtf::FormatDXT5,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (info->ctl_format), info->format);
gtk_table_attach (GTK_TABLE (table), info->ctl_format, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
label = gtk_label_new ("_Format:");
g_object_set (G_OBJECT (label),
"mnemonic-widget", info->ctl_format,
"use-underline", TRUE,
"xalign", 1.0,
NULL);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
info->ctl_layer = gimp_int_combo_box_new (
"Frames", 0,
"Faces", 1,
"Z slices", 2,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (info->ctl_layer), 0);
gtk_table_attach (GTK_TABLE (table), info->ctl_layer, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND), GTK_FILL, 0, 0);
label = gtk_label_new ("_Layers to:");
g_object_set (G_OBJECT (label),
"mnemonic-widget", info->ctl_layer,
"use-underline", TRUE,
"xalign", 1.0,
NULL);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
info->ctl_mipmap = gtk_check_button_new_with_label ("Add and generate _mipmaps");
g_object_set (G_OBJECT (info->ctl_mipmap),
"use-underline", TRUE,
"active", TRUE,
NULL);
gtk_table_attach (GTK_TABLE (table), info->ctl_mipmap, 0, 2, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
info->ctl_lowres = gtk_check_button_new_with_label ("Add low _resolution image");
g_object_set (G_OBJECT (info->ctl_lowres),
"use-underline", TRUE,
"active", TRUE,
NULL);
gtk_table_attach (GTK_TABLE (table), info->ctl_lowres, 0, 2, 4, 5,
GTK_FILL, GTK_FILL, 0, 0);
info->ctl_crc = gtk_check_button_new_with_label ("Add _CRC");
g_object_set (G_OBJECT (info->ctl_crc),
"use-underline", TRUE,
"active", TRUE,
NULL);
gtk_table_attach (GTK_TABLE (table), info->ctl_crc, 0, 2, 5, 6,
GTK_FILL, GTK_FILL, 0, 0);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
table, TRUE, TRUE, 0);
gtk_widget_show_all (table);
gtk_widget_show (dialog);
gint resp = gimp_dialog_run (GIMP_DIALOG (dialog));
gtk_widget_destroy (dialog);
return (resp == GTK_RESPONSE_OK);
}
static GObject*
webx_indexed_target_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
WebxIndexedTarget *indexed;
GtkWidget *radio;
GSList *radio_group;
GtkWidget *combo;
GtkWidget *label;
GtkWidget *separator;
gint row = 0;
object = G_OBJECT_CLASS (parent_class)->constructor (type,
n_params,
params);
indexed = WEBX_INDEXED_TARGET (object);
/*
* reuse existing
*/
radio = gtk_radio_button_new_with_label (NULL, _("Reuse existing palette"));
gtk_table_attach (GTK_TABLE (indexed), radio,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
g_signal_connect_swapped (GTK_WIDGET (radio), "toggled",
G_CALLBACK (webx_indexed_target_changed),
indexed);
indexed->reuse_pal_w = radio;
gtk_widget_show (radio);
/*
* generate optimum
*/
row++;
radio = gtk_radio_button_new_with_label (radio_group,
_("Generate optimum palette"));
gtk_table_attach (GTK_TABLE (indexed), radio,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
g_signal_connect_swapped (GTK_WIDGET (radio), "toggled",
G_CALLBACK (webx_indexed_target_changed),
indexed);
indexed->make_pal_w = radio;
gtk_widget_show (radio);
row++;
label = gtk_label_new (_("Number of colors:"));
gtk_table_attach (GTK_TABLE (indexed), label,
0, 2, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
indexed->num_colors_w = gtk_spin_button_new_with_range (2, 256, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (indexed->num_colors_w), 256);
g_signal_connect_swapped (indexed->num_colors_w, "value-changed",
G_CALLBACK (webx_indexed_target_changed),
indexed);
gtk_table_attach (GTK_TABLE (indexed), indexed->num_colors_w,
2, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (indexed->num_colors_w);
/*
* web-optimized
*/
row++;
radio = gtk_radio_button_new_with_label (radio_group,
_("Use web-optimized palette"));
gtk_table_attach (GTK_TABLE (indexed), radio,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
g_signal_connect_swapped (GTK_WIDGET (radio), "toggled",
G_CALLBACK (webx_indexed_target_changed),
indexed);
indexed->web_pal_w = radio;
gtk_widget_show (radio);
/*
* b&w
*/
row++;
radio = gtk_radio_button_new_with_label (radio_group,
_("Use black and white palette"));
gtk_table_attach (GTK_TABLE (indexed), radio,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
g_signal_connect_swapped (GTK_WIDGET (radio), "toggled",
G_CALLBACK (webx_indexed_target_changed),
indexed);
indexed->bw_pal_w = radio;
gtk_widget_show (radio);
row++;
indexed->remove_unused_w = gtk_check_button_new_with_label (_("Remove unused colors"));
gtk_table_attach (GTK_TABLE (indexed), indexed->remove_unused_w,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect_swapped (indexed->remove_unused_w, "toggled",
G_CALLBACK (webx_indexed_target_changed),
indexed);
gtk_widget_show (indexed->remove_unused_w);
row++;
separator = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (indexed), separator,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 8);
row++;
label = gtk_label_new (_("Dither:"));
gtk_table_attach (GTK_TABLE (indexed), label,
0, 1, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
combo = gimp_int_combo_box_new (_("None"),
GIMP_NO_DITHER,
_("Floyd-Steinberg"),
GIMP_FS_DITHER,
_("Floyd-Steinberg 2"),
GIMP_FSLOWBLEED_DITHER,
_("Positioned"),
GIMP_FIXED_DITHER,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), GIMP_NO_DITHER);
gtk_table_attach (GTK_TABLE (indexed), combo,
1, 3, row, row+1,
GTK_SHRINK, GTK_SHRINK, 0, 0);
g_signal_connect_swapped (combo, "changed",
G_CALLBACK (webx_indexed_target_changed),
indexed);
indexed->dither_type_w = combo;
gtk_widget_show (combo);
row++;
indexed->alpha_dither_w = gtk_check_button_new_with_label (_("Dithering of transparency"));
gtk_table_attach (GTK_TABLE (indexed), indexed->alpha_dither_w,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect_swapped (indexed->alpha_dither_w, "toggled",
G_CALLBACK (webx_indexed_target_changed),
indexed);
gtk_widget_show (indexed->alpha_dither_w);
row++;
separator = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (indexed), separator,
0, 3, row, row+1,
GTK_FILL, GTK_FILL, 0, 8);
gtk_widget_show (separator);
indexed->last_row = ++row;
webx_indexed_target_changed (indexed);
return object;
}
static int
align_layers_dialog (void)
{
GtkWidget *dialog;
GtkWidget *table;
GtkWidget *combo;
GtkWidget *toggle;
GtkObject *adj;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Align Visible Layers"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, 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));
table = gtk_table_new (7, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
table, FALSE, FALSE, 0);
gtk_widget_show (table);
combo = gimp_int_combo_box_new (C_("align-style", "None"), H_NONE,
_("Collect"), H_COLLECT,
_("Fill (left to right)"), LEFT2RIGHT,
_("Fill (right to left)"), RIGHT2LEFT,
_("Snap to grid"), SNAP2HGRID,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.h_style);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&VALS.h_style);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("_Horizontal style:"), 0.0, 0.5,
combo, 2, FALSE);
combo = gimp_int_combo_box_new (_("Left edge"), H_BASE_LEFT,
_("Center"), H_BASE_CENTER,
_("Right edge"), H_BASE_RIGHT,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.h_base);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&VALS.h_base);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Ho_rizontal base:"), 0.0, 0.5,
combo, 2, FALSE);
combo = gimp_int_combo_box_new (C_("align-style", "None"), V_NONE,
_("Collect"), V_COLLECT,
_("Fill (top to bottom)"), TOP2BOTTOM,
_("Fill (bottom to top)"), BOTTOM2TOP,
_("Snap to grid"), SNAP2VGRID,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.v_style);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&VALS.v_style);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
_("_Vertical style:"), 0.0, 0.5,
combo, 2, FALSE);
combo = gimp_int_combo_box_new (_("Top edge"), V_BASE_TOP,
_("Center"), V_BASE_CENTER,
_("Bottom edge"), V_BASE_BOTTOM,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), VALS.v_base);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&VALS.v_base);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 3,
_("Ver_tical base:"), 0.0, 0.5,
combo, 2, FALSE);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 4,
_("_Grid size:"), SCALE_WIDTH, 0,
VALS.grid_size, 1, 200, 1, 10, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&VALS.grid_size);
toggle = gtk_check_button_new_with_mnemonic
(_("_Ignore the bottom layer even if visible"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), VALS.ignore_bottom);
gtk_table_attach_defaults (GTK_TABLE (table), toggle, 0, 3, 5, 6);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&VALS.ignore_bottom);
toggle = gtk_check_button_new_with_mnemonic
(_("_Use the (invisible) bottom layer as the base"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
VALS.base_is_bottom_layer);
gtk_table_attach_defaults (GTK_TABLE (table), toggle, 0, 3, 6, 7);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&VALS.base_is_bottom_layer);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}
/* This function creates and returns an hbox for an icon,
which then gets added to the dialog's main vbox. */
static GtkWidget *
ico_create_icon_hbox (GtkWidget *icon_preview,
gint32 layer,
gint layer_num,
IcoSaveInfo *info)
{
static GtkSizeGroup *size = NULL;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *alignment;
GtkWidget *combo;
GtkWidget *checkbox;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
alignment = gtk_alignment_new (1.0, 0.5, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), alignment, FALSE, FALSE, 0);
gtk_widget_show (alignment);
/* To make life easier for the callbacks, we store the
layer's ID and stacking number with the hbox. */
g_object_set_data (G_OBJECT (hbox),
"icon_layer", GINT_TO_POINTER (layer));
g_object_set_data (G_OBJECT (hbox),
"icon_layer_num", GINT_TO_POINTER (layer_num));
g_object_set_data (G_OBJECT (hbox), "icon_preview", icon_preview);
gtk_container_add (GTK_CONTAINER (alignment), icon_preview);
gtk_widget_show (icon_preview);
if (! size)
size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget (size, alignment);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
combo = gimp_int_combo_box_new (_("1 bpp, 1-bit alpha, 2-slot palette"), 1,
_("4 bpp, 1-bit alpha, 16-slot palette"), 4,
_("8 bpp, 1-bit alpha, 256-slot palette"), 8,
_("24 bpp, 1-bit alpha, no palette"), 24,
_("32 bpp, 8-bit alpha, no palette"), 32,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
info->depths[layer_num]);
g_signal_connect (combo, "changed",
G_CALLBACK (ico_dialog_bpp_changed),
hbox);
g_object_set_data (G_OBJECT (hbox), "icon_menu", combo);
gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
checkbox = gtk_check_button_new_with_label (_("Compressed (PNG)"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox),
info->compress[layer_num]);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (ico_dialog_toggle_compress), hbox);
gtk_box_pack_start (GTK_BOX (vbox), checkbox, FALSE, FALSE, 0);
gtk_widget_show (checkbox);
return hbox;
}
static gboolean
cm_dialog (CmParamsType *mix,
GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *image;
GtkWidget *table;
gdouble red_value, green_value, blue_value;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
/* get values */
if (mix->monochrome)
{
red_value = mix->black.red_gain * 100;
green_value = mix->black.green_gain * 100;
blue_value = mix->black.blue_gain * 100;
}
else
{
switch (mix->output_channel)
{
case CM_RED_CHANNEL:
red_value = mix->red.red_gain * 100;
green_value = mix->red.green_gain * 100;
blue_value = mix->red.blue_gain * 100;
break;
case CM_GREEN_CHANNEL:
red_value = mix->green.red_gain * 100;
green_value = mix->green.green_gain * 100;
blue_value = mix->green.blue_gain * 100;
break;
case CM_BLUE_CHANNEL:
red_value = mix->blue.red_gain * 100;
green_value = mix->blue.green_gain * 100;
blue_value = mix->blue.blue_gain * 100;
break;
default:
g_assert_not_reached ();
red_value = green_value = blue_value = 0.0;
break;
}
}
dialog = gimp_dialog_new (_("Channel Mixer"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, 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_vbox_new (FALSE, 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);
preview = gimp_zoom_preview_new (drawable);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (cm_preview),
mix);
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
hbox = gtk_hbox_new (FALSE, 6);
gtk_frame_set_label_widget (GTK_FRAME (frame), hbox);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("O_utput channel:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
mix->combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL);
gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo),
GIMP_INT_STORE_VALUE, CM_RED_CHANNEL,
GIMP_INT_STORE_LABEL, _("Red"),
GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_RED,
-1);
gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo),
GIMP_INT_STORE_VALUE, CM_GREEN_CHANNEL,
GIMP_INT_STORE_LABEL, _("Green"),
GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_GREEN,
-1);
gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (mix->combo),
GIMP_INT_STORE_VALUE, CM_BLUE_CHANNEL,
GIMP_INT_STORE_LABEL, _("Blue"),
GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_CHANNEL_BLUE,
-1);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo),
mix->output_channel);
g_signal_connect (mix->combo, "changed",
G_CALLBACK (cm_combo_callback),
mix);
gtk_box_pack_start (GTK_BOX (hbox), mix->combo, TRUE, TRUE, 0);
gtk_widget_show (mix->combo);
if (mix->monochrome)
gtk_widget_set_sensitive (mix->combo, FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), mix->combo);
/*........................................................... */
table = gtk_table_new (3, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED,
GTK_ICON_SIZE_BUTTON);
gtk_table_attach (GTK_TABLE (table), image,
0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (image);
mix->red_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 0,
_("_Red:"), 150, -1,
red_value, -200.0, 200.0,
1.0, 10.0, 1,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (mix->red_data, "value-changed",
G_CALLBACK (cm_red_scale_callback),
mix);
image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN,
GTK_ICON_SIZE_BUTTON);
gtk_table_attach (GTK_TABLE (table), image,
0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (image);
mix->green_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 1,
_("_Green:"), 150, -1,
green_value, -200.0, 200.0,
1.0, 10.0, 1,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (mix->green_data, "value-changed",
G_CALLBACK (cm_green_scale_callback),
mix);
image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE,
GTK_ICON_SIZE_BUTTON);
gtk_table_attach (GTK_TABLE (table), image,
0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (image);
mix->blue_data =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 1, 2,
_("_Blue:"), 150, -1,
blue_value, -200.0, 200.0,
1.0, 10.0, 1,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (mix->blue_data, "value-changed",
G_CALLBACK (cm_blue_scale_callback),
mix);
vbox = gtk_vbox_new (6, FALSE);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
/* The monochrome toggle */
mix->monochrome_toggle =
gtk_check_button_new_with_mnemonic (_("_Monochrome"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle),
mix->monochrome);
gtk_box_pack_start (GTK_BOX (vbox), mix->monochrome_toggle,
FALSE, FALSE, 0);
gtk_widget_show (mix->monochrome_toggle);
g_signal_connect (mix->monochrome_toggle, "toggled",
G_CALLBACK (cm_monochrome_callback),
mix);
/* The preserve luminosity toggle */
mix->preserve_luminosity_toggle =
gtk_check_button_new_with_mnemonic (_("Preserve _luminosity"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(mix->preserve_luminosity_toggle),
mix->preserve_luminosity);
gtk_box_pack_start (GTK_BOX (vbox), mix->preserve_luminosity_toggle,
FALSE, FALSE, 0);
gtk_widget_show (mix->preserve_luminosity_toggle);
g_signal_connect (mix->preserve_luminosity_toggle, "toggled",
G_CALLBACK (cm_preserve_luminosity_callback),
mix);
/*........................................................... */
/* Horizontal box for file i/o */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_end (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
button = gtk_button_new_from_stock (GTK_STOCK_OPEN);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (cm_load_file_callback),
mix);
button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (cm_save_file_callback),
mix);
button = gtk_button_new_from_stock (GIMP_STOCK_RESET);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (cm_reset_callback),
mix);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}
EnumWidget& operator=(int const& value)
{
gimp_int_combo_box_set_active(GIMP_INT_COMBO_BOX(this->gimpEnumComboBox), value);
return *this;
}
static gboolean
webpage_dialog (void)
{
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *entry;
GtkSizeGroup *sizegroup;
GtkAdjustment *adjustment;
GtkWidget *spinbutton;
GtkWidget *combo;
gint active;
gint status;
gboolean ret = FALSE;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Create from webpage"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("Cre_ate"), GTK_RESPONSE_OK,
NULL);
gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
image = gtk_image_new_from_icon_name (GIMP_ICON_WEB,
GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
gtk_widget_show (image);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Enter location (URI):"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_widget_set_size_request (entry, 400, -1);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
if (webpagevals.url)
gtk_entry_set_text (GTK_ENTRY (entry),
webpagevals.url);
gtk_widget_show (entry);
sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* Width */
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 (_("Width (pixels):"));
gtk_size_group_add_widget (sizegroup, label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adjustment = gtk_adjustment_new (webpagevals.width,
1, 8192, 1, 10, 0);
spinbutton = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
/* Font size */
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 (_("Font size:"));
gtk_size_group_add_widget (sizegroup, label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_int_combo_box_new (_("Huge"), 16,
_("Large"), 14,
C_("web-page", "Default"), 12,
_("Small"), 10,
_("Tiny"), 8,
NULL);
switch (webpagevals.font_size)
{
case 16:
case 14:
case 12:
case 10:
case 8:
active = webpagevals.font_size;
break;
default:
active = 12;
}
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), active);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
g_object_unref (sizegroup);
status = gimp_dialog_run (GIMP_DIALOG (dialog));
if (status == GTK_RESPONSE_OK)
{
g_free (webpagevals.url);
webpagevals.url = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
webpagevals.width = (gint) gtk_adjustment_get_value (adjustment);
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo),
&webpagevals.font_size);
ret = TRUE;
}
gtk_widget_destroy (dialog);
return ret;
}
static void
gimp_dynamics_editor_constructed (GObject *object)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (object);
GimpDynamicsEditor *editor = GIMP_DYNAMICS_EDITOR (object);
GimpDynamics *dynamics = editor->dynamics_model;
GtkWidget *input_labels[7];
GtkWidget *vbox;
GtkWidget *icon_box;
GtkWidget *grid;
gint n_inputs = G_N_ELEMENTS (input_labels);
gint i;
G_OBJECT_CLASS (parent_class)->constructed (object);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_notebook_append_page (GTK_NOTEBOOK (editor->notebook),
vbox, NULL);
gtk_widget_show (vbox);
icon_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), icon_box, FALSE, FALSE, 0);
gtk_widget_show (icon_box);
gimp_dynamics_editor_add_icon_editor (dynamics,
data_editor->context->gimp,
vbox);
grid = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
gimp_dynamics_editor_init_output_editors (dynamics,
editor->view_selector,
editor->notebook,
grid);
input_labels[0] = gtk_label_new (_("Pressure"));
input_labels[1] = gtk_label_new (_("Velocity"));
input_labels[2] = gtk_label_new (_("Direction"));
input_labels[3] = gtk_label_new (_("Tilt"));
input_labels[4] = gtk_label_new (_("Wheel/Rotation"));
input_labels[5] = gtk_label_new (_("Random"));
input_labels[6] = gtk_label_new (_("Fade"));
for (i = 0; i < n_inputs; i++)
{
gtk_label_set_angle (GTK_LABEL (input_labels[i]), 90);
gtk_label_set_yalign (GTK_LABEL (input_labels[i]), 1.0);
gtk_grid_attach (GTK_GRID (grid), input_labels[i], i + 1, 0, 1, 1);
gtk_widget_show (input_labels[i]);
}
gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (editor->view_selector),
GIMP_INT_STORE_VALUE, -1,
GIMP_INT_STORE_LABEL, _("Mapping matrix"),
GIMP_INT_STORE_USER_DATA, vbox,
-1);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (editor->view_selector), -1);
gimp_docked_set_show_button_bar (GIMP_DOCKED (object), FALSE);
}
static void
gimp_histogram_editor_init (GimpHistogramEditor *editor)
{
GimpHistogramView *view;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *menu;
GtkWidget *table;
gint i;
const gchar *gimp_histogram_editor_labels[] =
{
N_("Mean:"),
N_("Std dev:"),
N_("Median:"),
N_("Pixels:"),
N_("Count:"),
N_("Percentile:")
};
editor->drawable = NULL;
editor->histogram = NULL;
editor->bg_histogram = NULL;
editor->valid = FALSE;
editor->idle_id = 0;
editor->box = gimp_histogram_box_new ();
gimp_editor_set_show_name (GIMP_EDITOR (editor), TRUE);
view = GIMP_HISTOGRAM_BOX (editor->box)->view;
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Channel:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
editor->menu = menu = gimp_prop_enum_combo_box_new (G_OBJECT (view),
"histogram-channel",
0, 0);
gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (menu),
"gimp-channel");
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (editor->menu),
gimp_histogram_menu_sensitivity,
editor, NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (editor->menu),
view->channel);
gtk_box_pack_start (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
menu = gimp_prop_enum_stock_box_new (G_OBJECT (view),
"histogram-scale", "gimp-histogram",
0, 0);
gtk_box_pack_end (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
gtk_box_pack_start (GTK_BOX (editor), editor->box, TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET (editor->box));
g_signal_connect_swapped (view, "range-changed",
G_CALLBACK (gimp_histogram_editor_info_update),
editor);
g_signal_connect_swapped (view, "notify::histogram-channel",
G_CALLBACK (gimp_histogram_editor_info_update),
editor);
g_signal_connect_swapped (view, "expose-event",
G_CALLBACK (gimp_histogram_view_expose),
editor);
table = gtk_table_new (3, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 6);
gtk_box_pack_start (GTK_BOX (editor), table, FALSE, FALSE, 0);
gtk_widget_show (table);
for (i = 0; i < 6; i++)
{
gint x = (i / 3) * 2;
gint y = (i % 3);
label = gtk_label_new (gettext (gimp_histogram_editor_labels[i]));
gimp_label_set_attributes (GTK_LABEL (label),
PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, x, x + 1, y, y + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 2, 2);
gtk_widget_show (label);
editor->labels[i] =
label = g_object_new (GTK_TYPE_LABEL,
"xalign", 0.0,
"yalign", 0.5,
"width-chars", i > 2 ? 9 : 5,
NULL);
gimp_label_set_attributes (GTK_LABEL (editor->labels[i]),
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_table_attach (GTK_TABLE (table), label, x + 1, x + 2, y, y + 1,
GTK_FILL, GTK_FILL, 2, 2);
gtk_widget_show (label);
}
}
