/** * gimp_export_dialog_new: * @format_name: The short name of the image_format (e.g. JPEG or PNG). * @role: The dialog's @role which will be set with * gtk_window_set_role(). * @help_id: The GIMP help id. * * Creates a new export dialog. All file plug-ins should use this * dialog to get a consistent look on the export dialogs. Use * gimp_export_dialog_get_content_area() to get a #GtkVBox to be * filled with export options. The export dialog is a wrapped * #GimpDialog. * * The dialog response when the user clicks on the Export button is * %GTK_RESPONSE_OK, and when the Cancel button is clicked it is * %GTK_RESPONSE_CANCEL. * * Returns: The new export dialog. * * Since: 2.8 **/ GtkWidget * gimp_export_dialog_new (const gchar *format_name, const gchar *role, const gchar *help_id) { GtkWidget *dialog = NULL; GtkWidget *button = NULL; gchar *title = g_strconcat (_("Export Image as "), format_name, NULL); dialog = gimp_dialog_new (title, role, NULL, 0, gimp_standard_help_func, help_id, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gimp_dialog_add_button (GIMP_DIALOG (dialog), _("_Export"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("document-save", GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); g_free (title); return dialog; }
/* show our results */ static void doDialog (void) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *preview; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Colorcube Analysis"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); 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); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); /* use preview for histogram window */ preview = gimp_preview_area_new (); gtk_widget_set_size_request (preview, PREWIDTH, PREHEIGHT); gtk_container_add (GTK_CONTAINER (frame), preview); /* output results */ doLabel (vbox, _("Image dimensions: %d × %d"), width, height); if (uniques == 0) doLabel (vbox, _("No colors")); else if (uniques == 1) doLabel (vbox, _("Only one unique color")); else doLabel (vbox, _("Number of unique colors: %d"), uniques); /* show stuff */ gtk_widget_show_all (dialog); fillPreview (preview); gimp_dialog_run (GIMP_DIALOG (dialog)); gtk_widget_destroy (dialog); }
/* Build the dialog up. This was the hard part! */ static gint sel2path_dialog (SELVALS *sels) { GtkWidget *dlg; GtkWidget *table; retVal = FALSE; gimp_ui_init (PLUG_IN_BINARY, FALSE); dlg = gimp_dialog_new (_("Selection to Path Advanced Settings"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, "plug-in-sel2path-advanced", GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); g_signal_connect (dlg, "response", G_CALLBACK (sel2path_response), NULL); g_signal_connect (dlg, "destroy", G_CALLBACK (gtk_main_quit), NULL); table = dialog_create_selection_area (sels); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), table, TRUE, TRUE, 0); gtk_widget_show (table); gtk_widget_show (dlg); gtk_main (); return retVal; }
static gboolean octave_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *button_update; gboolean run; //default entries: reset_default(); gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new("Hipstagram", PLUG_IN_BINARY, NULL, (GtkDialogFlags)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_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox); gtk_widget_show (main_vbox); // preview preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect(preview, "invalidated", G_CALLBACK (preview_update),NULL); // update button button_update = gtk_button_new_with_label("Update"); gtk_box_pack_start (GTK_BOX (main_vbox), button_update, TRUE, TRUE, 0); gtk_widget_show (button_update); g_signal_connect_swapped (button_update, "released", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean polarize_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkWidget *hbox; GtkWidget *toggle; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Polar Coordinates"), PLUG_IN_BINARY, 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_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); /* Preview */ preview = gimp_zoom_preview_new (drawable); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (dialog_update_preview), drawable); /* Controls */ table = gtk_table_new (2, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Circle _depth in percent:"), SCALE_WIDTH, 0, pcvals.circle, 0.0, 100.0, 1.0, 10.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &pcvals.circle); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("Offset _angle:"), SCALE_WIDTH, 0, pcvals.angle, 0.0, 359.0, 1.0, 15.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &pcvals.angle); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* togglebuttons for backwards, top, polar->rectangular */ hbox = gtk_hbox_new (TRUE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); toggle = gtk_check_button_new_with_mnemonic (_("_Map backwards")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), pcvals.backwards); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If checked the mapping will begin at the right " "side, as opposed to beginning at the left."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &pcvals.backwards); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic (_("Map from _top")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), pcvals.inverse); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If unchecked the mapping will put the bottom " "row in the middle and the top row on the " "outside. If checked it will be the opposite."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &pcvals.inverse); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic (_("To _polar")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), pcvals.polrec); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If unchecked the image will be circularly " "mapped onto a rectangle. If checked the image " "will be mapped onto a circle."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &pcvals.polrec); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (hbox); /* Done */ gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean neon_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkObject *scale_data; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Neon Detection"), 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_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); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (neon_preview_update), NULL); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Label, scale, entry for evals.radius */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Radius:"), 100, 8, evals.radius, 0.0, 64.0, 1, 10, 2, FALSE, 0.0, 8 * MAX (drawable->width, drawable->height), NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &evals.radius); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Label, scale, entry for evals.amount */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Amount:"), 100, 8, evals.amount, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &evals.amount); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean plugin_dialog (piArgs *argp) { GtkWidget *dlg; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *toggle; GtkWidget *frame; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dlg = gimp_dialog_new (_("Hot"), PLUG_IN_BINARY, 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 (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Mode"), G_CALLBACK (gimp_radio_button_update), &argp->mode, argp->mode, "N_TSC", MODE_NTSC, NULL, "_PAL", MODE_PAL, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); toggle = gtk_check_button_new_with_mnemonic (_("Create _new layer")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), argp->new_layerp); 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), &argp->new_layerp); frame = gimp_int_radio_group_new (TRUE, _("Action"), G_CALLBACK (gimp_radio_button_update), &argp->action, argp->action, _("Reduce _Luminance"), ACT_LREDUX, NULL, _("Reduce _Saturation"), ACT_SREDUX, NULL, _("_Blacken"), ACT_FLAG, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }
static gboolean save_dialog (void) { GtkWidget *dlg; GtkWidget *main_vbox; GtkWidget *entry; GtkWidget *table; GtkWidget *scrolled_window; GtkWidget *text_view; GtkTextBuffer *text_buffer; gchar *gump_from; gint row = 0; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); /* check gimprc for a preferred "From:" address */ gump_from = gimp_gimprc_query ("gump-from"); if (gump_from) { g_strlcpy (mail_info.from, gump_from, BUFFER_SIZE); g_free (gump_from); } dlg = gimp_dialog_new (_("Send by Email"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Send"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); 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 (dlg))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); /* table */ table = gtk_table_new (5, 2, FALSE); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12); gtk_table_set_col_spacings (GTK_TABLE (table), 6); /* Filename entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.filename); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("_Filename:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.filename); /* To entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.receipt); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, C_("email-address", "_To:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.receipt); gtk_widget_grab_focus (entry); /* From entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.from); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, C_("email-address", "_From:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.from); /* Subject entry */ entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_max_length (GTK_ENTRY (entry), BUFFER_SIZE - 1); gtk_entry_set_text (GTK_ENTRY (entry), mail_info.subject); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, _("S_ubject:"), 0.0, 0.5, entry, 1, FALSE); g_signal_connect (entry, "changed", G_CALLBACK (mail_entry_callback), mail_info.subject); /* Body */ 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_box_pack_start (GTK_BOX (main_vbox), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); text_buffer = gtk_text_buffer_new (NULL); g_signal_connect (text_buffer, "changed", G_CALLBACK (mesg_body_callback), NULL); gtk_text_buffer_set_text (text_buffer, mail_info.comment, -1); text_view = gtk_text_view_new_with_buffer (text_buffer); g_object_unref (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); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }
static void open_dialog (void) { GtkWidget *dialog; GtkWidget *main_hbox; GtkWidget *button; GtkObject *adjustment; GtkWidget *vbox; GtkWidget *table; GtkWidget *frame; GtkWidget *color_button; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Paper Tile"), 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_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* Left */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Division")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); button = gimp_spin_button_new (&w.division_x_adj, p.params.division_x, 1.0, p.drawable->width, 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_X:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.division_x_adj, "value-changed", G_CALLBACK (division_x_adj_changed), NULL); button = gimp_spin_button_new (&w.division_y_adj, p.params.division_y, 1.0, p.drawable->width, 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("_Y:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.division_y_adj, "value-changed", G_CALLBACK (division_y_adj_changed), NULL); button = gimp_spin_button_new (&w.tile_width_adj, p.params.tile_width, 1.0, MAX (p.drawable->width, p.drawable->height), 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("_Width:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.tile_width_adj, "value-changed", G_CALLBACK (tile_width_adj_changed), NULL); button = gimp_spin_button_new (&w.tile_height_adj, p.params.tile_height, 1.0, MAX (p.drawable->width, p.drawable->height), 1.0, 5.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("_Height:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (w.tile_height_adj, "value-changed", G_CALLBACK (tile_height_adj_changed), NULL); frame = gimp_int_radio_group_new (TRUE, _("Fractional Pixels"), G_CALLBACK (gimp_radio_button_update), &p.params.fractional_type, p.params.fractional_type, _("_Background"), FRACTIONAL_TYPE_BACKGROUND, NULL, _("_Ignore"), FRACTIONAL_TYPE_IGNORE, NULL, _("_Force"), FRACTIONAL_TYPE_FORCE, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); button = gtk_check_button_new_with_mnemonic(_("C_entering")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), p.params.centering); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &p.params.centering); /* Right */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Movement")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); button = gimp_spin_button_new (&adjustment, p.params.move_max_rate, 0.0, 100.0, 1.0, 10.0, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Max (%):"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &p.params.move_max_rate); button = gtk_check_button_new_with_mnemonic (_("_Wrap around")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), p.params.wrap_around); gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 2, 1, 2); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &p.params.wrap_around); frame = gimp_int_radio_group_new (TRUE, _("Background Type"), G_CALLBACK (gimp_radio_button_update), &p.params.background_type, p.params.background_type, _("_Transparent"), BACKGROUND_TYPE_TRANSPARENT, NULL, _("I_nverted image"), BACKGROUND_TYPE_INVERTED, NULL, _("Im_age"), BACKGROUND_TYPE_IMAGE, NULL, _("Fo_reground color"), BACKGROUND_TYPE_FOREGROUND, NULL, _("Bac_kground color"), BACKGROUND_TYPE_BACKGROUND, NULL, _("S_elect here:"), BACKGROUND_TYPE_COLOR, &button, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); color_button = gimp_color_button_new (_("Background Color"), 100, 16, &p.params.background_color, p.drawable_has_alpha ? GIMP_COLOR_AREA_SMALL_CHECKS : GIMP_COLOR_AREA_FLAT); gtk_box_pack_start (GTK_BOX (gtk_bin_get_child (GTK_BIN (frame))), color_button, TRUE, TRUE, 0); gtk_widget_show (color_button); g_signal_connect (color_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &p.params.background_color); g_object_bind_property (button, "active", color_button, "sensitive", G_BINDING_SYNC_CREATE); gtk_widget_show (dialog); p.run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); }
static gboolean mblur_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *table; GtkWidget *entry; GtkWidget *spinbutton; GtkWidget *label; GtkWidget *button; GtkObject *adj; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Motion Blur"), PLUG_IN_BINARY, 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_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (mblur), drawable); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Blur Type"), G_CALLBACK (mblur_radio_button_update), &mbvals.mblur_type, mbvals.mblur_type, _("_Linear"), MBLUR_LINEAR, NULL, _("_Radial"), MBLUR_RADIAL, NULL, _("_Zoom"), MBLUR_ZOOM, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); center = gimp_frame_new (_("Blur Center")); gtk_box_pack_start (GTK_BOX (hbox), center, FALSE, FALSE, 0); gtk_widget_show (center); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (center), vbox); gtk_widget_show (vbox); gimp_image_get_resolution (image_ID, &xres, &yres); entry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 5, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); g_signal_connect (entry, "value-changed", G_CALLBACK (mblur_center_update), NULL); g_signal_connect_swapped (entry, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, 1, 0, 1, 1, 10, 1, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, mbvals.center_x); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X:"), 0, 0, 0.0); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, mbvals.center_y); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y:"), 1, 0, 0.0); button = gtk_check_button_new_with_mnemonic (_("Blur _outward")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), mbvals.blur_outward); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &mbvals.blur_outward); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); dir_button = button; frame = gimp_frame_new (_("Blur Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); length = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("L_ength:"), 150, 3, mbvals.length, 1.0, MBLUR_LENGTH_MAX, 1.0, 8.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (length, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.length); g_signal_connect_swapped (length, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); angle = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Angle:"), 150, 3, mbvals.angle, 0.0, 360.0, 1.0, 15.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (angle, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.angle); g_signal_connect_swapped (angle, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); mblur_set_sensitivity (); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean load_dialog (const gchar *filename) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkObject *adj; guchar *pixels; gboolean run = FALSE; WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION, - WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE }; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Render Windows Metafile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, LOAD_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); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 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, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The WMF preview */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); pixels = wmf_get_pixbuf (filename, &vals.width, &vals.height); image = gimp_preview_area_new (); gtk_widget_set_size_request (image, vals.width, vals.height); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); g_signal_connect (image, "size-allocate", G_CALLBACK (wmf_preview_callback), pixels); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_wmf_size (filename, &vals); wmf_width = vals.width; wmf_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, wmf_width); gimp_size_entry_set_refval (size, 1, wmf_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_width, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small ? does libwmf tend to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); gtk_widget_show (dialog); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); run = TRUE; } gtk_widget_destroy (GTK_WIDGET (dialog)); return run; }
static gboolean sobel_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *toggle; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Sobel Edge Detection"), 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_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (sobel_preview_update), NULL); toggle = gtk_check_button_new_with_mnemonic (_("Sobel _horizontally")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &bvals.horizontal); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic (_("Sobel _vertically")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.vertical); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &bvals.vertical); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic (_("_Keep sign of result " "(one direction only)")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.keep_sign); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &bvals.keep_sign); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean glasstile_dialog (GimpDrawable *drawable) { GlassChainedValues *gv; GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkWidget *chainbutton; gboolean run; gv = g_new (GlassChainedValues, 1); gv->gval = >vals; gtvals.constrain = TRUE; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Glass Tile"), 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_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (glasstile), drawable); /* Parameter settings */ table = gtk_table_new (2, 4, 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), 2, 2); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Horizontal scale - Width */ gv->xadj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Tile _width:"), 150, 0, gtvals.xblock, 10, 50, 2, 10, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (gv->xadj, "value-changed", G_CALLBACK (glasstile_size_changed), gv); g_signal_connect_swapped (gv->xadj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Horizontal scale - Height */ gv->yadj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("Tile _height:"), 150, 0, gtvals.yblock, 10, 50, 2, 10, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (gv->yadj, "value-changed", G_CALLBACK (glasstile_size_changed), gv); g_signal_connect_swapped (gv->yadj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); chainbutton = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chainbutton), gtvals.constrain); gtk_table_attach_defaults (GTK_TABLE(table), chainbutton, 3, 4, 0, 2); g_signal_connect (chainbutton, "toggled", G_CALLBACK (glasstile_chain_toggled), >vals.constrain); gtk_widget_show (chainbutton); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean create_main_dialog (void) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *table; GtkWidget *combo; GtkObject *scale_data; gint row; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Van Gogh (LIC)"), 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)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Effect Channel"), G_CALLBACK (gimp_radio_button_update), &licvals.effect_channel, licvals.effect_channel, _("_Hue"), 0, NULL, _("_Saturation"), 1, NULL, _("_Brightness"), 2, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); frame = gimp_int_radio_group_new (TRUE, _("Effect Operator"), G_CALLBACK (gimp_radio_button_update), &licvals.effect_operator, licvals.effect_operator, _("_Derivative"), 0, NULL, _("_Gradient"), 1, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); frame = gimp_int_radio_group_new (TRUE, _("Convolve"), G_CALLBACK (gimp_radio_button_update), &licvals.effect_convolve, licvals.effect_convolve, _("_With white noise"), 0, NULL, _("W_ith source image"), 1, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* Effect image menu */ table = gtk_table_new (1, 2, 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); combo = gimp_drawable_combo_box_new (effect_image_constrain, NULL); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), licvals.effect_image_id, G_CALLBACK (gimp_int_combo_box_get_active), &licvals.effect_image_id); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Effect image:"), 0.0, 0.5, combo, 2, TRUE); table = gtk_table_new (5, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); row = 0; scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++, _("_Filter length:"), 0, 6, licvals.filtlen, 0.1, 64, 1.0, 8.0, 1, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &licvals.filtlen); scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++, _("_Noise magnitude:"), 0, 6, licvals.noisemag, 1, 5, 0.1, 1.0, 1, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &licvals.noisemag); scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++, _("In_tegration steps:"), 0, 6, licvals.intsteps, 1, 40, 1.0, 5.0, 1, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &licvals.intsteps); scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++, _("_Minimum value:"), 0, 6, licvals.minv, -100, 0, 1, 10, 1, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &licvals.minv); scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, row++, _("M_aximum value:"), 0, 6, licvals.maxv, 0, 100, 1, 10, 1, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &licvals.maxv); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
/* show our dialog */ static gboolean exchange_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *preview; GtkWidget *table; GtkWidget *threshold; GtkWidget *colorbutton; GtkObject *adj; GtkSizeGroup *group; gint framenumber; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Color Exchange"), 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)); /* do some boxes here */ 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 (_("Middle-Click Inside Preview to " "Pick \"From Color\"")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); preview = gimp_drawable_preview_new (drawable, NULL); gtk_container_add (GTK_CONTAINER (frame), preview); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (exchange), drawable); g_signal_connect (GIMP_PREVIEW (preview)->area, "event", G_CALLBACK (preview_event_handler), preview); /* a hidden color_button to handle the threshold more easily */ threshold = gimp_color_button_new (NULL, 1, 1, &xargs.threshold, GIMP_COLOR_AREA_FLAT); g_signal_connect (threshold, "color-changed", G_CALLBACK (gimp_color_button_get_color), &xargs.threshold); g_signal_connect (threshold, "color-changed", G_CALLBACK (color_button_callback), &xargs.threshold); g_signal_connect_swapped (threshold, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* and our scales */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); for (framenumber = 0; framenumber < 2; framenumber++) { GtkWidget *vbox; GtkWidget *image; gint row = 0; frame = gimp_frame_new (framenumber ? _("To Color") : _("From Color")); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); table = gtk_table_new (framenumber ? 4 : 8, 4, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 12); if (! framenumber) { gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 3, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 5, 2); } gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); colorbutton = gimp_color_button_new (framenumber ? _("Color Exchange: To Color") : _("Color Exchange: From Color"), SCALE_WIDTH / 2, 16, (framenumber ? &xargs.to : &xargs.from), GIMP_COLOR_AREA_FLAT); gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, NULL, 0.0, 0.0, colorbutton, 1, FALSE); g_signal_connect (colorbutton, "color-changed", G_CALLBACK (gimp_color_button_get_color), framenumber ? &xargs.to : &xargs.from); g_signal_connect (colorbutton, "color-changed", G_CALLBACK (color_button_callback), framenumber ? &xargs.to : &xargs.from); g_signal_connect_swapped (colorbutton, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); if (! framenumber) from_colorbutton = colorbutton; /* Red */ image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED, GTK_ICON_SIZE_BUTTON); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5); gtk_table_attach (GTK_TABLE (table), image, 0, 1, row, row + 1 + (framenumber ? 0 : 1), GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (image); adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++, _("_Red:"), SCALE_WIDTH, 0, framenumber ? xargs.to.r : xargs.from.r, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_object_set_data (G_OBJECT (adj), "colorbutton", colorbutton); g_object_set_data (G_OBJECT (colorbutton), "red", adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), framenumber ? &xargs.to.r : &xargs.from.r); g_signal_connect (adj, "value-changed", G_CALLBACK (scale_callback), framenumber ? &xargs.to : &xargs.from); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj)); if (! framenumber) { adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++, _("R_ed threshold:"), SCALE_WIDTH, 0, xargs.threshold.r, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_object_set_data (G_OBJECT (adj), "colorbutton", threshold); g_object_set_data (G_OBJECT (threshold), "red", adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &xargs.threshold.r); g_signal_connect (adj, "value-changed", G_CALLBACK (scale_callback), &xargs.threshold); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj)); } /* Green */ image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN, GTK_ICON_SIZE_BUTTON); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5); gtk_table_attach (GTK_TABLE (table), image, 0, 1, row, row + 1 + (framenumber ? 0 : 1), GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (image); adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++, _("_Green:"), SCALE_WIDTH, 0, framenumber ? xargs.to.g : xargs.from.g, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_object_set_data (G_OBJECT (adj), "colorbutton", colorbutton); g_object_set_data (G_OBJECT (colorbutton), "green", adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), framenumber ? &xargs.to.g : &xargs.from.g); g_signal_connect (adj, "value-changed", G_CALLBACK (scale_callback), framenumber ? &xargs.to : &xargs.from); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj)); if (! framenumber) { adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++, _("G_reen threshold:"), SCALE_WIDTH, 0, xargs.threshold.g, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_object_set_data (G_OBJECT (adj), "colorbutton", threshold); g_object_set_data (G_OBJECT (threshold), "green", adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &xargs.threshold.g); g_signal_connect (adj, "value-changed", G_CALLBACK (scale_callback), &xargs.threshold); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj)); } /* Blue */ image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE, GTK_ICON_SIZE_BUTTON); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5); gtk_table_attach (GTK_TABLE (table), image, 0, 1, row, row + 1 + (framenumber ? 0 : 1), GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (image); adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++, _("_Blue:"), SCALE_WIDTH, 0, framenumber ? xargs.to.b : xargs.from.b, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_object_set_data (G_OBJECT (adj), "colorbutton", colorbutton); g_object_set_data (G_OBJECT (colorbutton), "blue", adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), framenumber ? &xargs.to.b : &xargs.from.b); g_signal_connect (adj, "value-changed", G_CALLBACK (scale_callback), framenumber ? &xargs.to : &xargs.from); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj)); if (! framenumber) { adj = gimp_scale_entry_new (GTK_TABLE (table), 1, row++, _("B_lue threshold:"), SCALE_WIDTH, 0, xargs.threshold.b, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_object_set_data (G_OBJECT (adj), "colorbutton", threshold); g_object_set_data (G_OBJECT (threshold), "blue", adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &xargs.threshold.b); g_signal_connect (adj, "value-changed", G_CALLBACK (scale_callback), &xargs.threshold); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj)); } if (! framenumber) { GtkWidget *button; button = gtk_check_button_new_with_mnemonic (_("Lock _thresholds")); gtk_table_attach (GTK_TABLE (table), button, 2, 4, row, row + 1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), lock_threshold); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_toggle_button_update), &lock_threshold); g_signal_connect_swapped (button, "clicked", G_CALLBACK (gimp_preview_invalidate), preview); } } g_object_unref (group); /* show everything */ gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
/* -------------------------- * p_align_dialog * -------------------------- */ static void p_align_dialog(AlignDialogVals *advPtr) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *label; GtkWidget *button; GtkWidget *table; GtkWidget *vbox1; GSList *vbox1_group = NULL; GtkWidget *radiobutton; gint row; advPtr->runExactAlign = FALSE; gimp_ui_init (GAP_EXACT_ALIGNER_PLUG_IN_NAME_BINARY, TRUE); dialog = gimp_dialog_new (_("Transform Layer via 4 (or 2) point Alignment"), GAP_EXACT_ALIGNER_PLUG_IN_NAME_BINARY, NULL, 0, gimp_standard_help_func, GAP_EXACT_ALIGNER_PLUG_IN_NAME, GTK_STOCK_REFRESH, GAP_RESPONSE_REFRESH_PATH, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); advPtr->shell = dialog; button = gimp_dialog_add_button (GIMP_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); advPtr->okButton = button; 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_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (on_exact_align_response), advPtr); /* Controls */ table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); row = 0; /* info label */ label = gtk_label_new ("--"); advPtr->infoLabel = label; gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 3, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); row++; /* pointOrder radiobutton * POINT_ORDER_MODE_31_42: compatible to the exact aligner script (from the plugin registry) */ label = gtk_label_new (_("Path Point Order:")); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); /* vbox for radio group */ vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_table_attach (GTK_TABLE (table), vbox1, 1, 3, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); /* Order Mode the radio buttons */ radiobutton = gtk_radio_button_new_with_label (vbox1_group, _("( 3 --> 1 ) ( 4 --> 2 )\nTarget is marked by points 1&2 ")); advPtr->radio_order_mode_31_42 = radiobutton; vbox1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton)); gtk_widget_show (radiobutton); gtk_box_pack_start (GTK_BOX (vbox1), radiobutton, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (radiobutton), "clicked", G_CALLBACK (on_order_mode_radio_callback), advPtr); if(advPtr->pointOrder == POINT_ORDER_MODE_31_42) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (radiobutton), TRUE); } radiobutton = gtk_radio_button_new_with_label (vbox1_group, "( 2 --> 1 ) ( 4 --> 3 )\nTarget is marked by points 1&3"); advPtr->radio_order_mode_21_43 = radiobutton; vbox1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton)); gtk_widget_show (radiobutton); gtk_box_pack_start (GTK_BOX (vbox1), radiobutton, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (radiobutton), "clicked", G_CALLBACK (on_order_mode_radio_callback), advPtr); if(advPtr->pointOrder == POINT_ORDER_MODE_21_43) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (radiobutton), TRUE); } p_refresh_and_update_infoLabel(NULL, advPtr); /* Done */ gtk_widget_show (dialog); gtk_main (); gdk_flush (); } /* end p_align_dialog */
static gboolean ripple_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *toggle; GtkWidget *toggle_vbox; GtkWidget *frame; GtkWidget *table; GtkObject *scale_data; GtkWidget *horizontal; GtkWidget *vertical; GtkWidget *wrap; GtkWidget *smear; GtkWidget *blank; GtkWidget *sawtooth; GtkWidget *sine; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Ripple"), 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)); /* The main vbox */ 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); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (ripple), drawable); /* The table to hold the four frames of options */ table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_table_set_row_spacings (GTK_TABLE (table), 12); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); /* Options section */ frame = gimp_frame_new ( _("Options")); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (frame); toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), toggle_vbox); gtk_widget_show (toggle_vbox); toggle = gtk_check_button_new_with_mnemonic (_("_Antialiasing")); gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), rvals.antialias); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &rvals.antialias); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic ( _("_Retain tilability")); gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), (rvals.tile)); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &rvals.tile); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); /* Orientation toggle box */ frame = gimp_int_radio_group_new (TRUE, _("Orientation"), G_CALLBACK (gimp_radio_button_update), &rvals.orientation, rvals.orientation, _("_Horizontal"), GIMP_ORIENTATION_HORIZONTAL, &horizontal, _("_Vertical"), GIMP_ORIENTATION_VERTICAL, &vertical, NULL); 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); g_signal_connect_swapped (horizontal, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (vertical, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); /* Edges toggle box */ frame = gimp_int_radio_group_new (TRUE, _("Edges"), G_CALLBACK (gimp_radio_button_update), &rvals.edges, rvals.edges, _("_Wrap"), WRAP, &wrap, _("_Smear"), SMEAR, &smear, _("_Blank"), BLANK, &blank, NULL); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); gtk_widget_show (frame); g_object_bind_property (toggle, "active", frame, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_signal_connect_swapped (wrap, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (smear, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (blank, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); /* Wave toggle box */ frame = gimp_int_radio_group_new (TRUE, _("Wave Type"), G_CALLBACK (gimp_radio_button_update), &rvals.waveform, rvals.waveform, _("Saw_tooth"), SAWTOOTH, &sawtooth, _("S_ine"), SINE, &sine, NULL); gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); gtk_widget_show (frame); g_signal_connect_swapped (sawtooth, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (sine, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (table); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); /* Period */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Period:"), SCALE_WIDTH, 0, rvals.period, 1, 200, 1, 10, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &rvals.period); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Amplitude */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("A_mplitude:"), SCALE_WIDTH, 0, rvals.amplitude, 0, 200, 1, 10, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &rvals.amplitude); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Phase Shift */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Phase _shift:"), SCALE_WIDTH, 0, rvals.phase_shift, 0, 360, 1, 15, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &rvals.phase_shift); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (frame); gtk_widget_show (table); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean dialog (void) { /* Missing options: Color-dialogs? / own curl layer ? / transparency to original drawable / Warp-curl (unsupported yet) */ GtkWidget *dialog; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *table; GtkWidget *frame; GtkWidget *button; GtkWidget *combo; GtkObject *adjustment; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Pagecurl Effect"), 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)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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); frame = gimp_frame_new (_("Curl Location")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (3, 2, TRUE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); curl_image = gtk_image_new (); gtk_table_attach (GTK_TABLE (table), curl_image, 0, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (curl_image); curl_pixbuf_update (); { static const gchar *name[] = { N_("Lower right"), N_("Lower left"), N_("Upper left"), N_("Upper right") }; gint i; button = NULL; for (i = CURL_EDGE_FIRST; i <= CURL_EDGE_LAST; i++) { button = gtk_radio_button_new_with_label (button == NULL ? NULL : gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), gettext (name[i - CURL_EDGE_FIRST])); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.edge == i); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (i)); gtk_table_attach (GTK_TABLE (table), button, CURL_EDGE_LEFT (i) ? 0 : 1, CURL_EDGE_LEFT (i) ? 1 : 2, CURL_EDGE_UPPER (i) ? 0 : 2, CURL_EDGE_UPPER (i) ? 1 : 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_radio_button_update), &curl.edge); g_signal_connect (button, "toggled", G_CALLBACK (curl_pixbuf_update), NULL); } } gtk_widget_show (table); gtk_widget_show (frame); frame = gimp_frame_new (_("Curl Orientation")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE); gtk_container_add (GTK_CONTAINER (frame), hbox); { static const gchar *name[] = { N_("_Vertical"), N_("_Horizontal") }; gint i; button = NULL; for (i = 0; i <= CURL_ORIENTATION_LAST; i++) { button = gtk_radio_button_new_with_mnemonic (button == NULL ? NULL : gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), gettext (name[i])); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.orientation == i); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (i)); gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_radio_button_update), &curl.orientation); g_signal_connect (button, "toggled", G_CALLBACK (curl_pixbuf_update), NULL); } } gtk_widget_show (hbox); gtk_widget_show (frame); button = gtk_check_button_new_with_mnemonic (_("_Shade under curl")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.shade); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &curl.shade); combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL); gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_VALUE, CURL_COLORS_GRADIENT_REVERSE, GIMP_INT_STORE_LABEL, _("Current gradient (reversed)"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_GRADIENT, -1); gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_VALUE, CURL_COLORS_GRADIENT, GIMP_INT_STORE_LABEL, _("Current gradient"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_GRADIENT, -1); gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_VALUE, CURL_COLORS_FG_BG, GIMP_INT_STORE_LABEL, _("Foreground / background colors"), GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_DEFAULT_COLORS, -1); gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), curl.colors, G_CALLBACK (gimp_int_combo_box_get_active), &curl.colors); gtk_widget_show (dialog); 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); adjustment = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Opacity:"), 100, 0, curl.opacity * 100.0, 0.0, 100.0, 1.0, 1.0, 0.0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adjustment, "value-changed", G_CALLBACK (dialog_scale_update), &curl.opacity); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean vpropagate_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *table; GtkWidget *toggle_vbox; GtkWidget *button; GtkObject *adj; GSList *group = NULL; gint index = 0; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Value Propagate"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, VPROPAGATE_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_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); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (value_propagate_body), drawable); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* Propagate Mode */ frame = gimp_frame_new (_("Mode")); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (frame), toggle_vbox); gtk_widget_show (toggle_vbox); for (index = 0; index < num_mode; index++) { button = gtk_radio_button_new_with_mnemonic (group, gettext (modes[index].name)); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (toggle_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (index)); g_signal_connect (button, "toggled", G_CALLBACK (gimp_radio_button_update), &vpvals.propagate_mode); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), index == vpvals.propagate_mode); } /* Parameter settings */ frame = gimp_frame_new (_("Propagate")); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (8, 3, FALSE); /* 4 raw, 2 columns(name and value) */ gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 12); gtk_table_set_row_spacing (GTK_TABLE (table), 5, 12); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Lower t_hreshold:"), SCALE_WIDTH, 4, vpvals.lower_limit, 0, 255, 1, 8, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &vpvals.lower_limit); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Upper threshold:"), SCALE_WIDTH, 4, vpvals.upper_limit, 0, 255, 1, 8, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &vpvals.upper_limit); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("_Propagating rate:"), SCALE_WIDTH, 4, vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &vpvals.propagating_rate); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_table_add_toggle (table, _("To l_eft"), 0, 1, 4, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Right2Left]); gtk_table_add_toggle (table, _("To _right"), 2, 3, 4, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Left2Right]); gtk_table_add_toggle (table, _("To _top"), 1, 2, 3, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Bottom2Top]); gtk_table_add_toggle (table, _("To _bottom"), 1, 2, 5, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Top2Bottom]); if (gimp_drawable_has_alpha (drawable->drawable_id)) { GtkWidget *toggle; toggle = gtk_table_add_toggle (table, _("Propagating _alpha channel"), 0, 3, 6, G_CALLBACK (vpropagate_toggle_button_update), &propagate_alpha); if (gimp_layer_get_lock_alpha (drawable->drawable_id)) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0); gtk_widget_set_sensitive (toggle, FALSE); } gtk_table_add_toggle (table, _("Propagating value channel"), 0, 3, 7, G_CALLBACK (vpropagate_toggle_button_update), &propagate_value); } gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { gint i, result; for (i = result = 0; i < 4; i++) result |= (direction_mask_vec[i] ? 1 : 0) << i; vpvals.direction_mask = result; vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) | (propagate_value ? PROPAGATING_VALUE : 0)); } gtk_widget_destroy (dialog); return run; }
static gboolean jpeg_exif_rotate_query_dialog (gint32 image_ID) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *label; GtkWidget *toggle; GdkPixbuf *pixbuf; gint response; dialog = gimp_dialog_new (_("Rotate Image?"), PLUG_IN_BINARY, NULL, 0, NULL, NULL, _("_Keep Orientation"), GTK_RESPONSE_CANCEL, GIMP_STOCK_TOOL_ROTATE, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); pixbuf = gimp_image_get_thumbnail (image_ID, THUMBNAIL_SIZE, THUMBNAIL_SIZE, GIMP_PIXBUF_SMALL_CHECKS); if (pixbuf) { GtkWidget *image; gchar *name; image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0); gtk_widget_show (image); name = gimp_image_get_name (image_ID); label = gtk_label_new (name); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (name); } vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = g_object_new (GTK_TYPE_LABEL, "label", _("According to the EXIF data, " "this image is rotated."), "wrap", TRUE, "justify", GTK_JUSTIFY_LEFT, "xalign", 0.0, "yalign", 0.5, NULL); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); label = g_object_new (GTK_TYPE_LABEL, "label", _("Would you like GIMP to rotate it " "into the standard orientation?"), "wrap", TRUE, "justify", GTK_JUSTIFY_LEFT, "xalign", 0.0, "yalign", 0.5, NULL); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); toggle = gtk_check_button_new_with_mnemonic (_("_Don't ask me again")); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE); gtk_widget_show (toggle); response = gimp_dialog_run (GIMP_DIALOG (dialog)); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle))) { GimpParasite *parasite; const gchar *str = (response == GTK_RESPONSE_OK) ? "yes" : "no"; parasite = gimp_parasite_new (JPEG_EXIF_ROTATE_PARASITE, GIMP_PARASITE_PERSISTENT, strlen (str), str); gimp_parasite_attach (parasite); gimp_parasite_free (parasite); } gtk_widget_destroy (dialog); return (response == GTK_RESPONSE_OK); }
gint sinus_dialog (void) { GtkWidget *dlg; GtkWidget *main_hbox; GtkWidget *preview; GtkWidget *notebook; GtkWidget *page; GtkWidget *frame; GtkWidget *label; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *table; GtkWidget *toggle; GtkWidget *push_col1 = NULL; GtkWidget *push_col2 = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); /* Create Main window with a vbox */ /* ============================== */ dlg = gimp_dialog_new (_("Sinus"), PLUG_IN_BINARY, 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 (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); main_hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* Create preview */ /* ============== */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); preview = mw_preview_new (vbox, thePreview); /* Create the notebook */ /* =================== */ notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (main_hbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); /* Create the drawing settings frame */ /* ================================= */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); frame = gimp_frame_new (_("Drawing Settings")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER(frame), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_X scale:"), 140, 8, svals.scalex, 0.0001, 100.0, 0.0001, 5, 4, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.scalex); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Y scale:"), 140, 8, svals.scaley, 0.0001, 100.0, 0.0001, 5, 4, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.scaley); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Co_mplexity:"), 140, 8, svals.cmplx, 0.0, 15.0, 0.01, 5, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.cmplx); gtk_widget_show (table); frame= gimp_frame_new (_("Calculation Settings")); gtk_box_pack_start (GTK_BOX (page), 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); table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); hbox = gimp_random_seed_new (&svals.seed, &svals.random_seed); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("R_andom seed:"), 1.0, 0.5, hbox, 1, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), GIMP_RANDOM_SEED_SPINBUTTON (hbox)); g_signal_connect (GIMP_RANDOM_SEED_SPINBUTTON_ADJ (hbox), "value-changed", G_CALLBACK (sinus_random_update), NULL); gtk_widget_show (table); toggle = gtk_check_button_new_with_mnemonic (_("_Force tiling?")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), svals.tiling); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (sinus_toggle_button_update), &svals.tiling); vbox2 = gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (sinus_radio_button_update), &svals.perturbation, svals.perturbation, _("_Ideal"), IDEAL, NULL, _("_Distorted"), PERTURBED, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); label = gtk_label_new_with_mnemonic (_("_Settings")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); /* Color settings dialog: */ /* ====================== */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); if (drawable_is_grayscale) { frame = gimp_frame_new (_("Colors")); gtk_box_pack_start(GTK_BOX(page), 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); /*if in grey scale, the colors are necessarily black and white */ label = gtk_label_new (_("The colors are white and black.")); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_container_add (GTK_CONTAINER (vbox), label); gtk_widget_show (label); } else { frame = gimp_int_radio_group_new (TRUE, _("Colors"), G_CALLBACK (sinus_radio_button_update), &svals.colors, svals.colors, _("Bl_ack & white"), B_W, NULL, _("_Foreground & background"), USE_FG_BG, NULL, _("C_hoose here:"), USE_COLORS, NULL, NULL); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = GTK_BIN (frame)->child; hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); push_col1 = gimp_color_button_new (_("First color"), 32, 32, &svals.col1, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_box_pack_start (GTK_BOX (hbox), push_col1, FALSE, FALSE, 0); gtk_widget_show (push_col1); g_signal_connect (push_col1, "color-changed", G_CALLBACK (gimp_color_button_get_color), &svals.col1); push_col2 = gimp_color_button_new (_("Second color"), 32, 32, &svals.col2, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_box_pack_start (GTK_BOX (hbox), push_col2, FALSE, FALSE, 0); gtk_widget_show (push_col2); g_signal_connect (push_col2, "color-changed", G_CALLBACK (gimp_color_button_get_color), &svals.col2); gtk_widget_show (hbox); } frame = gimp_frame_new (_("Alpha Channels")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_widget_set_sensitive (frame, gimp_drawable_has_alpha (drawable->drawable_id)); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("F_irst color:"), 0, 0, svals.col1.a, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (alpha_scale_cb), push_col1); if (push_col1) g_signal_connect (push_col1, "color-changed", G_CALLBACK (alpha_scale_update), adj); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("S_econd color:"), 0, 0, svals.col2.a, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (alpha_scale_cb), push_col2); if (push_col2) g_signal_connect (push_col2, "color-changed", G_CALLBACK (alpha_scale_update), adj); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("Co_lors")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); /* blend settings dialog: */ /* ====================== */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); frame = gimp_frame_new (_("Blend Settings")); gtk_box_pack_start (GTK_BOX (page), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Gradient"), G_CALLBACK (sinus_radio_button_update), &svals.colorization, svals.colorization, _("L_inear"), LINEAR, NULL, _("Bili_near"), BILINEAR, NULL, _("Sin_usoidal"), SINUS, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (vbox), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Exponent:"), 0, 0, svals.blend_power, -7.5, 7.5, 0.01, 5.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.blend_power); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("_Blend")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); gtk_widget_show (dlg); sinus_do_preview (preview); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }
/* * Create dialog for red eye removal */ static gboolean dialog (gint32 image_id, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *preview; GtkWidget *table; GtkWidget *main_vbox; GtkObject *adj; gboolean run = FALSE; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Red Eye Removal"), 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_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); preview = gimp_zoom_preview_new (drawable); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); adj = gimp_scale_entry_new (GTK_TABLE (table), 1, 0, _("_Threshold:"), SCALE_WIDTH, 0, threshold, 0, 100, 1, 5, 0, TRUE, 0, 100, _("Threshold for the red eye color to remove."), NULL); if (gimp_selection_is_empty (gimp_item_get_image (drawable->drawable_id))) { GtkWidget *hints = gimp_hint_box_new (_("Manually selecting the eyes may " "improve the results.")); gtk_box_pack_end (GTK_BOX (main_vbox), hints, FALSE, FALSE, 0); gtk_widget_show (hints); } g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (remove_redeye_preview), drawable); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &threshold); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean cartoon_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkObject *scale_data; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Cartoon"), PLUG_IN_BINARY, 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_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (cartoon), drawable); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Label, scale, entry for cvals.amount */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Mask radius:"), 100, 5, cvals.mask_radius, 1.0, 50.0, 1, 5.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &cvals.mask_radius); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Label, scale, entry for cvals.amount */ scale_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Percent black:"), 50, 5, cvals.pct_black, 0.0, 1.0, 0.01, 0.1, 3, TRUE, 0, 0, NULL, NULL); g_signal_connect (scale_data, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &cvals.pct_black); g_signal_connect_swapped (scale_data, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean lcms_icc_apply_dialog (gint32 image, cmsHPROFILE src_profile, cmsHPROFILE dest_profile, gboolean *dont_ask) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *label; GtkWidget *button; GtkWidget *toggle = NULL; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Convert to RGB working space?"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC_APPLY, _("_Keep"), GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Convert"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GTK_STOCK_CONVERT, GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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); label = lcms_icc_profile_src_label_new (image, src_profile); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); label = lcms_icc_profile_dest_label_new (dest_profile); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); if (dont_ask) { toggle = gtk_check_button_new_with_mnemonic (_("_Don't ask me again")); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE); gtk_widget_show (toggle); } run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); *dont_ask = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)); gtk_widget_destroy (dialog); return run; }
static gint dog_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *coord; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("DoG Edge Detect"), PLUG_IN_BINARY, 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_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (preview_update_preview), drawable); frame = gimp_frame_new (_("Smoothing Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); coord = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, TRUE, _("_Radius 1:"), dogvals.inner, xres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0, _("R_adius 2:"), dogvals.outer, yres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0); gtk_container_add (GTK_CONTAINER (frame), coord); gtk_widget_show (coord); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (coord), 1); g_signal_connect (coord, "value-changed", G_CALLBACK (change_radius_callback), preview); button = gtk_check_button_new_with_mnemonic (_("_Normalize")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.normalize); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.normalize); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); button = gtk_check_button_new_with_mnemonic (_("_Invert")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.invert); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.invert); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); } gtk_widget_destroy (dialog); return run; }
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 gboolean tile_dialog (gint32 image_ID, gint32 drawable_ID) { GtkWidget *dlg; GtkWidget *vbox; GtkWidget *frame; GtkWidget *sizeentry; GtkWidget *chainbutton; GtkWidget *toggle; gint width; gint height; gdouble xres; gdouble yres; GimpUnit unit; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); width = gimp_drawable_width (drawable_ID); height = gimp_drawable_height (drawable_ID); unit = gimp_image_get_unit (image_ID); gimp_image_get_resolution (image_ID, &xres, &yres); tvals.new_width = width; tvals.new_height = height; dlg = gimp_dialog_new (_("Tile"), PLUG_IN_BINARY, 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 (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); 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 (dlg))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Tile to New Size")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, 8, GIMP_SIZE_ENTRY_UPDATE_SIZE, tvals.constrain, TRUE, _("_Width:"), width, xres, 1, GIMP_MAX_IMAGE_SIZE, 0, width, _("_Height:"), height, yres, 1, GIMP_MAX_IMAGE_SIZE, 0, height); gtk_container_add (GTK_CONTAINER (frame), sizeentry); gtk_table_set_row_spacing (GTK_TABLE (sizeentry), 1, 6); gtk_widget_show (sizeentry); chainbutton = GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (sizeentry)); toggle = gtk_check_button_new_with_mnemonic (_("C_reate new image")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), tvals.new_image); 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), &tvals.new_image); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); if (run) { tvals.new_width = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 0)); tvals.new_height = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 1)); tvals.constrain = gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (chainbutton)); } gtk_widget_destroy (dlg); return run; }
static gint alienmap2_dialog (void) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *top_table; GtkWidget *frame; GtkWidget *toggle; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *table; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Alien Map"), 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_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); 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 (dialog_update_preview), drawable); top_table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (top_table), 12); gtk_table_set_row_spacings (GTK_TABLE (top_table), 12); gtk_box_pack_start (GTK_BOX (main_vbox), top_table, FALSE, FALSE, 0); gtk_widget_show (top_table); /* Controls */ table = gtk_table_new (6, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 4); gtk_table_attach (GTK_TABLE (top_table), table, 0, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_show (table); entry_freq_rh = adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, NULL, SCALE_WIDTH, ENTRY_WIDTH, wvals.redfrequency, 0, 20.0, 0.1, 1, 2, TRUE, 0, 0, _("Number of cycles covering full value range"), NULL); label_freq_rh = GIMP_SCALE_ENTRY_LABEL (adj); g_signal_connect (adj, "value-changed", G_CALLBACK (dialog_scale_update), &wvals.redfrequency); entry_phase_rh = adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, NULL, SCALE_WIDTH, ENTRY_WIDTH, wvals.redangle, 0, 360.0, 1, 15, 2, TRUE, 0, 0, _("Phase angle, range 0-360"), NULL); label_phase_rh = GIMP_SCALE_ENTRY_LABEL (adj); g_signal_connect (adj, "value-changed", G_CALLBACK (dialog_scale_update), &wvals.redangle); entry_freq_gs = adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, NULL, SCALE_WIDTH, ENTRY_WIDTH, wvals.greenfrequency, 0, 20.0, 0.1, 1, 2, TRUE, 0, 0, _("Number of cycles covering full value range"), NULL); label_freq_gs = GIMP_SCALE_ENTRY_LABEL (adj); g_signal_connect (adj, "value-changed", G_CALLBACK (dialog_scale_update), &wvals.greenfrequency); entry_phase_gs = adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 3, NULL, SCALE_WIDTH, ENTRY_WIDTH, wvals.redangle, 0, 360.0, 1, 15, 2, TRUE, 0, 0, _("Phase angle, range 0-360"), NULL); label_phase_gs = GIMP_SCALE_ENTRY_LABEL (adj); g_signal_connect (adj, "value-changed", G_CALLBACK (dialog_scale_update), &wvals.greenangle); entry_freq_bl = adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 4, NULL, SCALE_WIDTH, ENTRY_WIDTH, wvals.bluefrequency, 0, 20.0, 0.1, 1, 2, TRUE, 0, 0, _("Number of cycles covering full value range"), NULL); label_freq_bl = GIMP_SCALE_ENTRY_LABEL (adj); g_signal_connect (adj, "value-changed", G_CALLBACK (dialog_scale_update), &wvals.bluefrequency); entry_phase_bl = adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 5, NULL, SCALE_WIDTH, ENTRY_WIDTH, wvals.blueangle, 0, 360.0, 1, 15, 2, TRUE, 0, 0, _("Phase angle, range 0-360"), NULL); label_phase_bl = GIMP_SCALE_ENTRY_LABEL (adj); g_signal_connect (adj, "value-changed", G_CALLBACK (dialog_scale_update), &wvals.blueangle); /* Mode toggle box */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_table_attach (GTK_TABLE (top_table), hbox, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Mode"), G_CALLBACK (alienmap2_radio_update), &wvals.colormodel, wvals.colormodel, _("_RGB color model"), RGB_MODEL, NULL, _("_HSL color model"), HSL_MODEL, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); toggle_modify_rh = toggle = gtk_check_button_new_with_mnemonic (NULL); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), wvals.redmode); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (alienmap2_toggle_update), &wvals.redmode); toggle_modify_gs = toggle = gtk_check_button_new_with_mnemonic (NULL); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), wvals.greenmode); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (alienmap2_toggle_update), &wvals.greenmode); toggle_modify_bl = toggle = gtk_check_button_new_with_mnemonic (NULL); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), wvals.bluemode); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (alienmap2_toggle_update), &wvals.bluemode); gtk_widget_show (frame); gtk_widget_show (dialog); alienmap2_get_label_size (); alienmap2_set_labels (); alienmap2_set_sensitive (); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean pixelize_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *sizeentry; guint32 image_id; GimpUnit unit; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Pixelize"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PIXELIZE_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_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (pixelize), drawable); image_id = gimp_drawable_get_image (drawable->drawable_id); unit = gimp_image_get_unit (image_id); gimp_image_get_resolution (image_id, &xres, &yres); sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, ENTRY_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE, TRUE, FALSE, _("Pixel _width:"), pvals.pixelwidth, xres, 1, drawable->width, 1, drawable->width, _("Pixel _height:"), pvals.pixelheight, yres, 1, drawable->height, 1, drawable->height); gtk_box_pack_start (GTK_BOX (main_vbox), sizeentry, FALSE, FALSE, 0); gtk_widget_show (sizeentry); g_signal_connect (sizeentry, "value-changed", G_CALLBACK (update_pixelsize), preview); g_signal_connect (sizeentry, "refval-changed", G_CALLBACK (update_pixelsize), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean decompose_dialog (void) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *combo; GtkWidget *toggle; gint j; gint extract_idx; gboolean run; extract_idx = 0; for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (extract[j].dialog && g_ascii_strcasecmp (decovals.extract_type, extract[j].type) == 0) { extract_idx = j; break; } } gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Decompose"), PLUG_IN_BINARY, 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); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); 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 (dialog)->vbox), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); frame = gimp_frame_new (_("Extract Channels")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 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 _model:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL); for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (extract[j].dialog) { gchar *label = g_strdup (gettext (extract[j].type)); gchar *l; for (l = label; *l; l++) if (*l == '-' || *l == '_') *l = ' '; gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_LABEL, label, GIMP_INT_STORE_VALUE, j, -1); g_free (label); } } gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), extract_idx, G_CALLBACK (gimp_int_combo_box_get_active), &extract_idx); toggle = gtk_check_button_new_with_mnemonic (_("_Decompose to layers")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), decovals.as_layers); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &decovals.as_layers); toggle = gtk_check_button_new_with_mnemonic (_("_Foreground as registration color")); gimp_help_set_help_data (toggle, _("Pixels in the foreground color will " "appear black in all output images. " "This can be used for things like crop " "marks that have to show up on all " "channels."), PLUG_IN_PROC); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), decovals.use_registration); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &decovals.use_registration); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); if (run) strncpy (decovals.extract_type, extract[extract_idx].type, sizeof decovals.extract_type - 1); return run; }