void documents_clear_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context = gimp_container_view_get_context (editor->view); Gimp *gimp = context->gimp; GtkWidget *dialog; dialog = gimp_message_dialog_new (_("Clear Document History"), GIMP_STOCK_SHRED, GTK_WIDGET (editor), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, gimp_standard_help_func, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CLEAR, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect_object (gtk_widget_get_toplevel (GTK_WIDGET (editor)), "unmap", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Clear the Recent Documents list?")); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Clearing the document history will " "permanently remove all images from " "the recent documents list.")); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { GtkRecentManager *manager = gtk_recent_manager_get_default (); GList *items; GList *list; items = gtk_recent_manager_get_items (manager); for (list = items; list; list = list->next) { GtkRecentInfo *info = list->data; if (gtk_recent_info_has_application (info, "GNU Image Manipulation Program")) { gtk_recent_manager_remove_item (manager, gtk_recent_info_get_uri (info), NULL); } gtk_recent_info_unref (info); } g_list_free (items); gimp_container_clear (gimp->documents); } gtk_widget_destroy (dialog); }
/*! \brief Creates the arc angle dialog * \par Function Description * This function creates the arc angle dialog. Depending on the * \a arc_object the entries are filled with the arc OBJECT properties * or with some standard values. * * \param [in] w_current The GschemToplevel object * \param [in] arc_object an arc OBJECT if used to modify an arc * or NULL to create a new arc. */ void arc_angle_dialog (GschemToplevel *w_current, OBJECT *arc_object) { GtkWidget *label[3]; GtkWidget *vbox; GtkWidget *alignment, *table; GtkWidget *widget[3]; if (!w_current->aawindow) { w_current->aawindow = gschem_dialog_new_with_buttons(_("Arc Params"), GTK_WINDOW(w_current->main_window), GTK_DIALOG_MODAL, "arc-angle", w_current, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->aawindow), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_REJECT, -1); gtk_window_set_position (GTK_WINDOW (w_current->aawindow), GTK_WIN_POS_MOUSE); g_signal_connect (G_OBJECT (w_current->aawindow), "response", G_CALLBACK (arc_angle_dialog_response), w_current); gtk_dialog_set_default_response(GTK_DIALOG(w_current->aawindow), GTK_RESPONSE_ACCEPT); gtk_container_set_border_width (GTK_CONTAINER (w_current->aawindow), DIALOG_BORDER_SPACING); vbox = GTK_DIALOG(w_current->aawindow)->vbox; gtk_box_set_spacing(GTK_BOX(vbox), DIALOG_V_SPACING); alignment = gtk_alignment_new(0,0,1,1); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 0 /*DIALOG_INDENTATION */, 0); gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, FALSE, 0); label[0] = gschem_dialog_misc_create_property_label (_("Arc _Radius:")); label[1] = gschem_dialog_misc_create_property_label (_("Start _Angle:")); label[2] = gschem_dialog_misc_create_property_label (_("_Degrees of Sweep:")); widget[0] = gtk_spin_button_new_with_range (1, 100000, 100); gtk_entry_set_activates_default (GTK_ENTRY(widget[0]), TRUE); widget[1] = gtk_spin_button_new_with_range (-360,360,1); gtk_entry_set_activates_default (GTK_ENTRY(widget[1]), TRUE); widget[2] = gtk_spin_button_new_with_range (-360,360,1); gtk_entry_set_activates_default(GTK_ENTRY(widget[2]), TRUE); table = gschem_dialog_misc_create_property_table (label, widget, 3); gtk_container_add (GTK_CONTAINER(alignment), table); GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[0], "radius"); GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[1],"spin_start"); GLADE_HOOKUP_OBJECT(w_current->aawindow, widget[2],"spin_sweep"); g_object_set_data(G_OBJECT(w_current->aawindow), "arc_object", arc_object); gtk_widget_show_all (w_current->aawindow); } else { /* dialog already created */ gtk_window_present (GTK_WINDOW(w_current->aawindow)); widget[0] = GTK_WIDGET (g_object_get_data (G_OBJECT (w_current->aawindow), "radius")); widget[1] = GTK_WIDGET (g_object_get_data (G_OBJECT (w_current->aawindow), "spin_start")); widget[2] = GTK_WIDGET (g_object_get_data (G_OBJECT (w_current->aawindow), "spin_sweep")); } if (arc_object == NULL) { gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[0]), w_current->distance); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[1]),0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[2]), 90); } else { gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[0]), geda_arc_object_get_radius (arc_object)); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[1]), geda_arc_object_get_start_angle (arc_object)); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget[2]), geda_arc_object_get_sweep_angle (arc_object)); } gtk_widget_grab_focus(widget[0]); }
static gboolean displace_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *table; GtkWidget *spinbutton; GtkObject *adj; GtkWidget *combo; GtkWidget *hbox; GtkWidget *frame; GtkWidget *wrap; GtkWidget *smear; GtkWidget *black; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Displace"), 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 (displace), drawable); /* The main table */ table = gtk_table_new (3, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 12); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0); /* X options */ toggle_x = gtk_check_button_new_with_mnemonic (_("_X displacement:")); gtk_table_attach (GTK_TABLE (table), toggle_x, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_x), dvals.do_x); gtk_widget_show (toggle_x); g_signal_connect (toggle_x, "toggled", G_CALLBACK (gimp_toggle_button_update), &dvals.do_x); g_signal_connect_swapped (toggle_x, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, dvals.amount_x, (gint) drawable->width * -2, drawable->width * 2, 1, 10, 0, 1, 2); gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &dvals.amount_x); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_set_sensitive (spinbutton, dvals.do_x); g_object_set_data (G_OBJECT (toggle_x), "set_sensitive", spinbutton); gtk_widget_show (spinbutton); combo = gimp_drawable_combo_box_new (displace_map_constrain, drawable); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dvals.displace_map_x, G_CALLBACK (gimp_int_combo_box_get_active), &dvals.displace_map_x); g_signal_connect_swapped (combo, "changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_table_attach (GTK_TABLE (table), combo, 2, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (combo); gtk_widget_set_sensitive (combo, dvals.do_x); g_object_set_data (G_OBJECT (spinbutton), "set_sensitive", combo); /* Y Options */ toggle_y = gtk_check_button_new_with_mnemonic (_("_Y displacement:")); gtk_table_attach (GTK_TABLE (table), toggle_y, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_y), dvals.do_y); gtk_widget_show (toggle_y); g_signal_connect (toggle_y, "toggled", G_CALLBACK (gimp_toggle_button_update), &dvals.do_y); g_signal_connect_swapped (toggle_y, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, dvals.amount_y, (gint) drawable->height * -2, drawable->height * 2, 1, 10, 0, 1, 2); gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &dvals.amount_y); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_set_sensitive (spinbutton, dvals.do_y); g_object_set_data (G_OBJECT (toggle_y), "set_sensitive", spinbutton); gtk_widget_show (spinbutton); combo = gimp_drawable_combo_box_new (displace_map_constrain, drawable); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dvals.displace_map_y, G_CALLBACK (gimp_int_combo_box_get_active), &dvals.displace_map_y); g_signal_connect_swapped (combo, "changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_table_attach (GTK_TABLE (table), combo, 2, 3, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (combo); gtk_widget_set_sensitive (combo, dvals.do_y); g_object_set_data (G_OBJECT (spinbutton), "set_sensitive", combo); hbox = gtk_hbox_new (FALSE, 24); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Displacement Mode"), G_CALLBACK (displace_radio_update), &dvals.mode, dvals.mode, _("_Cartesian"), CARTESIAN_MODE, NULL, _("_Polar"), POLAR_MODE, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); frame = gimp_int_radio_group_new (TRUE, _("Edge Behavior"), G_CALLBACK (gimp_radio_button_update), &dvals.displace_type, dvals.displace_type, _("_Wrap"), GIMP_PIXEL_FETCHER_EDGE_WRAP, &wrap, _("_Smear"), GIMP_PIXEL_FETCHER_EDGE_SMEAR, &smear, _("_Black"), GIMP_PIXEL_FETCHER_EDGE_BLACK, &black, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); 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 (black, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); displace_set_labels (); gtk_widget_show (table); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
void edit_undo_clear_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpUndoStack *undo_stack; GimpUndoStack *redo_stack; GtkWidget *widget; GtkWidget *dialog; gchar *size; gint64 memsize; gint64 guisize; return_if_no_image (image, data); return_if_no_widget (widget, data); dialog = gimp_message_dialog_new (_("Clear Undo History"), GIMP_STOCK_WARNING, widget, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, gimp_standard_help_func, GIMP_HELP_EDIT_UNDO_CLEAR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CLEAR, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect_object (gtk_widget_get_toplevel (widget), "unmap", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); g_signal_connect_object (image, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Really clear image's undo history?")); undo_stack = gimp_image_get_undo_stack (image); redo_stack = gimp_image_get_redo_stack (image); memsize = gimp_object_get_memsize (GIMP_OBJECT (undo_stack), &guisize); memsize += guisize; memsize += gimp_object_get_memsize (GIMP_OBJECT (redo_stack), &guisize); memsize += guisize; size = g_format_size (memsize); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Clearing the undo history of this " "image will gain %s of memory."), size); g_free (size); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { gimp_image_undo_disable (image); gimp_image_undo_enable (image); gimp_image_flush (image); } gtk_widget_destroy (dialog); }
void terminal_skey_do_popup (GtkWindow *window, TerminalScreen *screen, const gchar *skey_match) { GtkWidget *dialog, *label, *entry, *ok_button; char *title_text; char *seed; int seq; int hash = MD5; SkeyData *data; if (strncmp (SKEY_PREFIX, skey_match, strlen (SKEY_PREFIX)) == 0) { if (!extract_seq_and_seed (skey_match, &seq, &seed)) { terminal_util_show_error_dialog (window, NULL, NULL, _("The text you clicked on doesn't " "seem to be a valid S/Key " "challenge.")); return; } } else { if (!extract_hash_seq_and_seed (skey_match, &hash, &seq, &seed)) { terminal_util_show_error_dialog (window, NULL, NULL, _("The text you clicked on doesn't " "seem to be a valid OTP " "challenge.")); return; } } if (!terminal_util_load_builder_file ("skey-challenge.ui", "skey-dialog", &dialog, "skey-entry", &entry, "text-label", &label, "skey-ok-button", &ok_button, NULL)) { g_free (seed); return; } title_text = g_strdup_printf ("<big><b>%s</b></big>", gtk_label_get_text (GTK_LABEL (label))); gtk_label_set_label (GTK_LABEL (label), title_text); g_free (title_text); g_object_set_data (G_OBJECT (dialog), "skey-entry", entry); gtk_widget_grab_focus (entry); gtk_widget_grab_default (ok_button); gtk_entry_set_text (GTK_ENTRY (entry), ""); gtk_window_set_transient_for (GTK_WINDOW (dialog), window); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); /* FIXME: make this dialogue close if the screen closes! */ data = g_new (SkeyData, 1); data->hash = hash; data->seq = seq; data->seed = seed; data->screen = screen; g_signal_connect_data (dialog, "response", G_CALLBACK (skey_challenge_response_cb), data, (GClosureNotify) skey_data_free, 0); g_signal_connect (dialog, "delete-event", G_CALLBACK (terminal_util_dialog_response_on_delete), NULL); gtk_window_present (GTK_WINDOW (dialog)); }
/** @brief Creates the autonumber text dialog. * * Dialog is not shown. No callbacks are registered. This is basically * unmodified code returned by Glade. * * Only modification was the following substitution: * * %s/create_pixmap (autonumber_text, "\(.*\)")/autonumber_create_pixmap("gschem-\1", w_current)/ * * and addition of the "w_current" parameter. * * @param w_current Pointer to the top level struct. * @return Pointer to the dialog window. */ GtkWidget* autonumber_create_dialog(GschemToplevel *w_current) { GtkWidget *autonumber_text; GtkWidget *vbox1; GtkWidget *alignment1; GtkWidget *vbox3; GtkWidget *table1; GtkWidget *label4; GtkWidget *scope_text; GtkWidget *label8; GtkWidget *label6; GtkWidget *scope_number; GtkWidget *scope_skip; GtkWidget *scope_overwrite; GtkWidget *label1; GtkWidget *alignment3; GtkWidget *vbox4; GtkWidget *table3; GtkWidget *label12; GtkWidget *label13; GtkObject *opt_startnum_adj; GtkWidget *opt_startnum; GtkWidget *sort_order; GtkWidget *opt_removenum; GtkWidget *opt_slotting; GtkWidget *label3; autonumber_text = gschem_dialog_new_with_buttons(_("Autonumber text"), GTK_WINDOW(w_current->main_window), 0, /* not modal */ "autonumber", w_current, GTK_STOCK_CLOSE, GTK_RESPONSE_REJECT, GTK_STOCK_APPLY, GTK_RESPONSE_ACCEPT, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(autonumber_text), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_REJECT, -1); gtk_window_set_position (GTK_WINDOW (autonumber_text), GTK_WIN_POS_MOUSE); gtk_container_set_border_width (GTK_CONTAINER (autonumber_text), DIALOG_BORDER_SPACING); vbox1 = GTK_DIALOG(autonumber_text)->vbox; gtk_box_set_spacing(GTK_BOX(vbox1), DIALOG_V_SPACING); /* scope section */ label1 = gtk_label_new (_("<b>Scope</b>")); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_misc_set_alignment (GTK_MISC(label1), 0, 0); gtk_box_pack_start (GTK_BOX(vbox1), label1, TRUE, TRUE, 0); gtk_widget_show (label1); alignment1 = gtk_alignment_new (0, 0, 1, 1); gtk_widget_show (alignment1); gtk_box_pack_start (GTK_BOX (vbox1), alignment1, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, DIALOG_INDENTATION, 0); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox3); gtk_container_add (GTK_CONTAINER (alignment1), vbox3); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox3), table1, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table1), DIALOG_V_SPACING); gtk_table_set_col_spacings (GTK_TABLE (table1), DIALOG_H_SPACING); label4 = gtk_label_new (_("Search for:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); scope_text = gtk_combo_box_entry_new_text (); gtk_entry_set_activates_default(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(scope_text))), TRUE); gtk_widget_show (scope_text); gtk_table_attach (GTK_TABLE (table1), scope_text, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label8 = gtk_label_new (_("Autonumber text in:")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table1), label8, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); label6 = gtk_label_new (_("Skip numbers found in:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); scope_number = gtk_combo_box_new_text (); gtk_widget_show (scope_number); gtk_table_attach (GTK_TABLE (table1), scope_number, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (scope_number), _("Selected objects")); gtk_combo_box_append_text (GTK_COMBO_BOX (scope_number), _("Current page")); gtk_combo_box_append_text (GTK_COMBO_BOX (scope_number), _("Whole hierarchy")); scope_skip = gtk_combo_box_new_text (); gtk_widget_show (scope_skip); gtk_table_attach (GTK_TABLE (table1), scope_skip, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (scope_skip), _("Selected objects")); gtk_combo_box_append_text (GTK_COMBO_BOX (scope_skip), _("Current page")); gtk_combo_box_append_text (GTK_COMBO_BOX (scope_skip), _("Whole hierarchy")); scope_overwrite = gtk_check_button_new_with_mnemonic (_("Overwrite existing numbers")); gtk_widget_show (scope_overwrite); gtk_box_pack_start (GTK_BOX (vbox3), scope_overwrite, FALSE, FALSE, 6); /* Options section */ label3 = gtk_label_new (_("<b>Options</b>")); gtk_label_set_use_markup (GTK_LABEL (label3), TRUE); gtk_misc_set_alignment(GTK_MISC(label3), 0, 0); gtk_widget_show (label3); gtk_box_pack_start(GTK_BOX(vbox1), label3, TRUE, TRUE, 0); alignment3 = gtk_alignment_new (0, 0, 1, 1); gtk_widget_show (alignment3); gtk_box_pack_start(GTK_BOX(vbox1), alignment3, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 0, 0, DIALOG_INDENTATION, 0); vbox4 = gtk_vbox_new (FALSE, 3); gtk_widget_show (vbox4); gtk_container_add (GTK_CONTAINER (alignment3), vbox4); table3 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (vbox4), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), DIALOG_V_SPACING); gtk_table_set_col_spacings (GTK_TABLE (table3), DIALOG_H_SPACING); label12 = gtk_label_new (_("Starting number:")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table3), label12, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); label13 = gtk_label_new (_("Sort order:")); gtk_widget_show (label13); gtk_table_attach (GTK_TABLE (table3), label13, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5); opt_startnum_adj = gtk_adjustment_new (1, 0, 10000, 1, 10, 10); opt_startnum = gtk_spin_button_new (GTK_ADJUSTMENT (opt_startnum_adj), 1, 0); gtk_entry_set_activates_default(GTK_ENTRY(opt_startnum), TRUE); gtk_widget_show (opt_startnum); gtk_table_attach (GTK_TABLE (table3), opt_startnum, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); sort_order = gtk_combo_box_new(); gtk_widget_show (sort_order); gtk_table_attach (GTK_TABLE (table3), sort_order, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); opt_removenum = gtk_check_button_new_with_mnemonic (_("Remove numbers")); gtk_widget_show (opt_removenum); gtk_box_pack_start (GTK_BOX (vbox4), opt_removenum, FALSE, FALSE, 0); opt_slotting = gtk_check_button_new_with_mnemonic (_("Automatic slotting")); gtk_widget_show (opt_slotting); gtk_box_pack_start (GTK_BOX (vbox4), opt_slotting, FALSE, FALSE, 0); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT (autonumber_text, scope_text, "scope_text"); GLADE_HOOKUP_OBJECT (autonumber_text, scope_number, "scope_number"); GLADE_HOOKUP_OBJECT (autonumber_text, scope_skip, "scope_skip"); GLADE_HOOKUP_OBJECT (autonumber_text, scope_overwrite, "scope_overwrite"); GLADE_HOOKUP_OBJECT (autonumber_text, opt_startnum, "opt_startnum"); GLADE_HOOKUP_OBJECT (autonumber_text, sort_order, "sort_order"); GLADE_HOOKUP_OBJECT (autonumber_text, opt_removenum, "opt_removenum"); GLADE_HOOKUP_OBJECT (autonumber_text, opt_slotting, "opt_slotting"); return autonumber_text; }
static GtkWidget * create_dialog (void) { GtkWidget *notebook; GtkWidget *hbox; GtkWidget *preview_box; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("GIMPressionist"), 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)); g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), NULL); g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_main_quit), NULL); 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); preview_box = create_preview (); gtk_box_pack_start (GTK_BOX (hbox), preview_box, FALSE, FALSE, 0); gtk_widget_show (preview_box); notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 5); gtk_widget_show (notebook); create_presetpage (GTK_NOTEBOOK (notebook)); create_paperpage (GTK_NOTEBOOK (notebook)); create_brushpage (GTK_NOTEBOOK (notebook)); create_orientationpage (GTK_NOTEBOOK (notebook)); create_sizepage (GTK_NOTEBOOK (notebook)); create_placementpage (GTK_NOTEBOOK (notebook)); create_colorpage (GTK_NOTEBOOK (notebook)); create_generalpage (GTK_NOTEBOOK (notebook)); updatepreview (NULL, NULL); /* * This is to make sure the values from the pcvals will be reflected * in the GUI here. Otherwise they will be set to the defaults. * */ restore_values (); gtk_widget_show (dialog); return dialog; }
static GimpExportReturn export_dialog (GSList *actions, const gchar *format_name) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *image; GtkWidget *main_vbox; GtkWidget *label; GSList *list; gchar *text; GimpExportReturn retval; g_return_val_if_fail (actions != NULL, GIMP_EXPORT_CANCEL); g_return_val_if_fail (format_name != NULL, GIMP_EXPORT_CANCEL); dialog = gimp_dialog_new (_("Export File"), "gimp-export-image", NULL, 0, gimp_standard_help_func, "gimp-export-dialog", _("_Ignore"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Export"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_NO, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_widget_show (hbox); image = gtk_image_new_from_icon_name ("dialog-information", GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); /* the headline */ text = g_strdup_printf (_("Your image should be exported before it " "can be saved as %s for the following reasons:"), format_name); label = gtk_label_new (text); g_free (text); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); for (list = actions; list; list = g_slist_next (list)) { ExportAction *action = list->data; GtkWidget *frame; GtkWidget *vbox; text = g_strdup_printf (gettext (action->reason), format_name); frame = gimp_frame_new (text); g_free (text); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); if (action->possibilities[0] && action->possibilities[1]) { GtkWidget *button; GSList *radio_group = NULL; button = gtk_radio_button_new_with_label (radio_group, gettext (action->possibilities[0])); gtk_label_set_justify (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), GTK_JUSTIFY_LEFT); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (export_toggle_callback), &action->choice); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), (action->choice == 0)); gtk_widget_show (button); button = gtk_radio_button_new_with_label (radio_group, gettext (action->possibilities[1])); gtk_label_set_justify (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), GTK_JUSTIFY_LEFT); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), (action->choice == 1)); gtk_widget_show (button); } else if (action->possibilities[0]) { label = gtk_label_new (gettext (action->possibilities[0])); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); action->choice = 0; } gtk_widget_show (vbox); } /* the footline */ label = gtk_label_new (_("The export conversion won't modify your " "original image.")); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); switch (gimp_dialog_run (GIMP_DIALOG (dialog))) { case GTK_RESPONSE_OK: retval = GIMP_EXPORT_EXPORT; break; case GTK_RESPONSE_NO: retval = GIMP_EXPORT_IGNORE; break; default: retval = GIMP_EXPORT_CANCEL; break; } gtk_widget_destroy (dialog); return retval; }
static gboolean color_to_alpha_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *hbox; GtkWidget *button; GtkWidget *label; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Color to Alpha"), 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 (color_to_alpha_preview), drawable); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("From:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); button = gimp_color_button_new (_("Color to Alpha Color Picker"), PRV_WIDTH, PRV_HEIGHT, &pvals.color, GIMP_COLOR_AREA_FLAT); gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &pvals.color); g_signal_connect_swapped (button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); label = gtk_label_new (_("to alpha")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean remap_dialog (gint32 image_ID, guchar *map) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *box; GtkWidget *iconview; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; guchar *cmap; gint ncols, i; gboolean valid; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Rearrange Colormap"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC_REMAP, 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 (dialog), RESPONSE_RESET, 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); cmap = gimp_image_get_colormap (image_ID, &ncols); g_return_val_if_fail ((ncols > 0) && (ncols <= 256), FALSE); store = gtk_list_store_new (NUM_COLS, G_TYPE_INT, G_TYPE_STRING, GIMP_TYPE_RGB, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE); for (i = 0; i < ncols; i++) { GimpRGB rgb; GimpHSV hsv; gint index = map[i]; gchar *text = g_strdup_printf ("%d", index); gimp_rgb_set_uchar (&rgb, cmap[index * 3], cmap[index * 3 + 1], cmap[index * 3 + 2]); gimp_rgb_to_hsv (&rgb, &hsv); reverse_order[i] = ncols - i - 1; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLOR_INDEX, index, COLOR_INDEX_TEXT, text, COLOR_RGB, &rgb, COLOR_H, hsv.h, COLOR_S, hsv.s, COLOR_V, hsv.v, -1); g_free (text); } g_free (cmap); remap_ui = remap_ui_manager_new (dialog, store); iconview = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_box_pack_start (GTK_BOX (vbox), iconview, TRUE, TRUE, 0); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (iconview), GTK_SELECTION_SINGLE); gtk_icon_view_set_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_VERTICAL); gtk_icon_view_set_columns (GTK_ICON_VIEW (iconview), 16); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (iconview), TRUE); renderer = gimp_cell_renderer_color_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "color", COLOR_RGB, NULL); g_object_set (renderer, "width", 24, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "text", COLOR_INDEX_TEXT, NULL); g_object_set (renderer, "size-points", 6.0, "xalign", 0.5, "ypad", 0, NULL); g_signal_connect (iconview, "popup-menu", G_CALLBACK (remap_popup_menu), NULL); g_signal_connect (iconview, "button-press-event", G_CALLBACK (remap_button_press), NULL); box = gimp_hint_box_new (_("Drag and drop colors to rearrange the colormap. " "The numbers shown are the original indices. " "Right-click for a menu with sort options.")); gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0); gtk_widget_show (box); g_signal_connect (dialog, "response", G_CALLBACK (remap_response), store); gtk_widget_show_all (dialog); gtk_main (); i = 0; for (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter)) { gint index; gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COLOR_INDEX, &index, -1); map[i++] = index; } gtk_widget_destroy (dialog); return remap_run; }
static GimpExportReturn confirm_save_dialog (const gchar *message, const gchar *format_name) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *image; GtkWidget *main_vbox; GtkWidget *label; gchar *text; GimpExportReturn retval; g_return_val_if_fail (message != NULL, GIMP_EXPORT_CANCEL); g_return_val_if_fail (format_name != NULL, GIMP_EXPORT_CANCEL); dialog = gimp_dialog_new (_("Confirm Save"), "gimp-export-image-confirm", NULL, 0, gimp_standard_help_func, "gimp-export-confirm-dialog", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Confirm"), 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_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_widget_show (hbox); image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); text = g_strdup_printf (message, format_name); label = gtk_label_new (text); g_free (text); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); switch (gimp_dialog_run (GIMP_DIALOG (dialog))) { case GTK_RESPONSE_OK: retval = GIMP_EXPORT_EXPORT; break; default: retval = GIMP_EXPORT_CANCEL; break; } gtk_widget_destroy (dialog); return retval; }
int dialog_color_input_show(GtkWindow* parent, GlobalState* gs, struct ColorObject* color_object, struct ColorObject** new_color_object){ gchar* text = 0; Converter *converter; Converters *converters = (Converters*)dynv_get_pointer_wd(gs->params, "Converters", 0); converter = converters_get_first(converters, CONVERTERS_ARRAY_TYPE_DISPLAY); if (converter){ converter_get_text(converter->function_name, color_object, 0, gs->params, &text); } GtkWidget *dialog = gtk_dialog_new_with_buttons(_("Edit color"), parent, GtkDialogFlags(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), 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); GtkWidget* vbox = gtk_vbox_new(false, 5); GtkWidget* hbox = gtk_hbox_new(false, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, true, true, 0); GtkWidget *widget; widget = gtk_color_new(); gtk_color_set_rounded(GTK_COLOR(widget), true); gtk_color_set_hcenter(GTK_COLOR(widget), true); gtk_color_set_roundness(GTK_COLOR(widget), 5); Color c; color_object_get_color(color_object, &c); gtk_color_set_color(GTK_COLOR(widget), &c, ""); gtk_box_pack_start(GTK_BOX(hbox), widget, false, true, 0); gtk_box_pack_start(GTK_BOX(hbox), gtk_label_aligned_new(_("Color:"),0,0.5,0,0), false, false, 0); GtkWidget* entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(entry), true); gtk_box_pack_start(GTK_BOX(hbox), entry, true, true, 0); if (text){ gtk_entry_set_text(GTK_ENTRY(entry), text); g_free(text); } gtk_widget_show_all(vbox); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), vbox); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { struct ColorObject* color_object; if (main_get_color_object_from_text(gs, (char*)gtk_entry_get_text(GTK_ENTRY(entry)), &color_object)==0){ *new_color_object = color_object; gtk_widget_destroy(dialog); return 0; } } gtk_widget_destroy(dialog); return -1; }
void dialog_color_component_input_show(GtkWindow* parent, GtkColorComponent *color_component, int component_id, struct dynvSystem *params) { GtkColorComponentComp component = gtk_color_component_get_component(GTK_COLOR_COMPONENT(color_component)); ColorPickerComponentEditArgs *args = new ColorPickerComponentEditArgs; //args->color_picker = color_picker_args; args->params = params; args->component = component; args->component_id = component_id; memset(args->value, 0, sizeof(args->value)); GtkWidget *table; GtkWidget *dialog = gtk_dialog_new_with_buttons(_("Edit"), parent, GtkDialogFlags(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_default_size(GTK_WINDOW(dialog), dynv_get_int32_wd(args->params, "window.width", -1), dynv_get_int32_wd(args->params, "window.height", -1)); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); table = gtk_table_new(2, 2, FALSE); Color raw_color; gtk_color_component_get_raw_color(color_component, &raw_color); const ColorSpaceType *color_space_type = 0; for (uint32_t i = 0; i < color_space_count_types(); i++){ if (color_space_get_types()[i].comp_type == component){ color_space_type = &color_space_get_types()[i]; break; } } if (color_space_type){ for (int i = 0; i < color_space_type->n_items; i++){ gtk_table_attach(GTK_TABLE(table), gtk_label_aligned_new(color_space_type->items[i].name,0,0,0,0),0,1,i,i+1,GtkAttachOptions(GTK_FILL),GTK_FILL,5,5); args->value[i] = gtk_spin_button_new_with_range(color_space_type->items[i].min_value, color_space_type->items[i].max_value, color_space_type->items[i].step); gtk_entry_set_activates_default(GTK_ENTRY(args->value[i]), true); gtk_spin_button_set_value(GTK_SPIN_BUTTON(args->value[i]), raw_color.ma[i] * color_space_type->items[i].raw_scale); gtk_table_attach(GTK_TABLE(table), args->value[i],1,2,i,i+1,GtkAttachOptions(GTK_FILL | GTK_EXPAND),GTK_FILL,5,0); if (i == component_id) gtk_widget_grab_focus(args->value[i]); } } gtk_widget_show_all(table); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), table); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK){ if (color_space_type){ for (int i = 0; i < color_space_type->n_items; i++){ raw_color.ma[i] = gtk_spin_button_get_value(GTK_SPIN_BUTTON(args->value[i])) / color_space_type->items[i].raw_scale; } gtk_color_component_set_raw_color(color_component, &raw_color); } } gint width, height; gtk_window_get_size(GTK_WINDOW(dialog), &width, &height); dynv_set_int32(args->params, "window.width", width); dynv_set_int32(args->params, "window.height", height); gtk_widget_destroy(dialog); dynv_system_release(args->params); delete args; }
static void gimp_action_view_conflict_confirm (GimpActionView *view, GtkAction *action, guint accel_key, GdkModifierType accel_mask, const gchar *accel_path) { GimpActionGroup *group; gchar *label; gchar *accel_string; ConfirmData *confirm_data; GtkWidget *dialog; GimpMessageBox *box; g_object_get (action, "action-group", &group, NULL); label = gimp_strip_uline (gtk_action_get_label (action)); accel_string = gtk_accelerator_get_label (accel_key, accel_mask); confirm_data = g_slice_new (ConfirmData); confirm_data->manager = view->manager; confirm_data->accel_path = g_strdup (accel_path); confirm_data->accel_key = accel_key; confirm_data->accel_mask = accel_mask; dialog = gimp_message_dialog_new (_("Conflicting Shortcuts"), GIMP_STOCK_WARNING, gtk_widget_get_toplevel (GTK_WIDGET (view)), 0, gimp_standard_help_func, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Reassign shortcut"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect (dialog, "response", G_CALLBACK (gimp_action_view_conflict_response), confirm_data); box = GIMP_MESSAGE_DIALOG (dialog)->box; gimp_message_box_set_primary_text (box, _("Shortcut \"%s\" is already taken " "by \"%s\" from the \"%s\" group."), accel_string, label, group->label); gimp_message_box_set_text (box, _("Reassigning the shortcut will cause it " "to be removed from \"%s\"."), label); g_free (label); g_free (accel_string); g_object_unref (group); gtk_widget_show (dialog); }
/* dialog stuff */ static gint max_rgb_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *max; GtkWidget *min; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Maximum RGB Value"), 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_from_drawable_id (drawable->drawable_id); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (main_function), drawable); frame = gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (gimp_radio_button_update), &pvals.max_p, pvals.max_p, _("_Hold the maximal channels"), MAX_CHANNELS, &max, _("Ho_ld the minimal channels"), MIN_CHANNELS, &min, NULL); g_signal_connect_swapped (max, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (min, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean nova_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *table; GtkWidget *button; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Supernova"), 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_zoom_preview_new (drawable); gtk_widget_add_events (GIMP_PREVIEW (preview)->area, GDK_BUTTON_PRESS_MASK | GDK_BUTTON1_MOTION_MASK); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (nova), drawable); frame = nova_center_create (drawable, GIMP_PREVIEW (preview)); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 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); /* Color */ if (gimp_drawable_is_rgb (drawable->drawable_id)) { button = gimp_color_button_new (_("Supernova Color Picker"), SCALE_WIDTH - 8, 16, &pvals.color, GIMP_COLOR_AREA_FLAT); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Co_lor:"), 0.0, 0.5, button, 1, TRUE); g_signal_connect (button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &pvals.color); g_signal_connect_swapped (button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); } /* Radius */ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Radius:"), SCALE_WIDTH, 8, pvals.radius, 1, 100, 1, 10, 0, FALSE, 1, GIMP_MAX_IMAGE_SIZE, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &pvals.radius); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Number of spokes */ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("_Spokes:"), SCALE_WIDTH, 8, pvals.nspoke, 1, 1024, 1, 16, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &pvals.nspoke); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* Randomness of hue */ if (gimp_drawable_is_rgb (drawable->drawable_id)) { adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("R_andom hue:"), SCALE_WIDTH, 8, pvals.randomhue, 0, 360, 1, 15, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &pvals.randomhue); 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 GObject* settings_dlg_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *object; SettingsDlg *dialog; GtkWidget *frame; object = parent_class->constructor (type, n_construct_properties, construct_properties); dialog = SETTINGS_DLG (object); gpa_window_set_title (GTK_WINDOW (dialog), _("Settings")); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, GTK_RESPONSE_APPLY, -1); /* The UI mode section. */ frame = user_interface_mode_frame (dialog); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame, FALSE, FALSE, 0); /* The default key section. */ frame = default_key_frame (dialog); gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame); /* The default keyserver section. Note that there is no keyserver entry if we are using gnupg 2.1. There we do not have the keyserver helpers anymore and thus the keyservers are to be enabled in the backend preferences. */ #ifdef ENABLE_KEYSERVER_SUPPORT if (!dialog->gnupg21) { frame = default_keyserver_frame (dialog); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame, FALSE, FALSE, 0); } #endif /*ENABLE_KEYSERVER_SUPPORT*/ /* The auto key locate section. */ dialog->akl.enabled = dialog->gnupg21; if (dialog->akl.enabled) { frame = auto_key_locate_frame (dialog); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame, FALSE, FALSE, 0); } /* Connect the response signal. */ g_signal_connect (GTK_OBJECT (dialog), "response", G_CALLBACK (dialog_response), NULL); /* Load values. */ load_settings (dialog); /* Show all windows and hide those we don't want. */ gtk_widget_show_all (GTK_WIDGET(dialog)); update_show_advanced_options (dialog); return object; }
static GtkWidget * quit_close_all_dialog_new (Gimp *gimp, gboolean do_quit) { GimpContainer *images; GimpContext *context; GimpMessageBox *box; GtkWidget *dialog; GtkWidget *label; GtkWidget *button; GtkWidget *view; GtkWidget *dnd_widget; gint rows; gint view_size; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); /* FIXME: need container of dirty images */ images = gimp_displays_get_dirty_images (gimp); context = gimp_context_new (gimp, "close-all-dialog", gimp_get_user_context (gimp)); g_return_val_if_fail (images != NULL, NULL); dialog = gimp_message_dialog_new (do_quit ? _("Quit GIMP") : _("Close All Images"), GIMP_STOCK_WARNING, NULL, 0, gimp_standard_help_func, do_quit ? GIMP_HELP_FILE_QUIT : GIMP_HELP_FILE_CLOSE_ALL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); g_object_set_data_full (G_OBJECT (dialog), "dirty-images", images, (GDestroyNotify) g_object_unref); g_object_set_data_full (G_OBJECT (dialog), "dirty-images-context", context, (GDestroyNotify) g_object_unref); g_signal_connect (dialog, "response", G_CALLBACK (quit_close_all_dialog_response), gimp); box = GIMP_MESSAGE_DIALOG (dialog)->box; button = gtk_dialog_add_button (GTK_DIALOG (dialog), "", GTK_RESPONSE_OK); g_object_set_data (G_OBJECT (box), "ok-button", button); g_object_set_data (G_OBJECT (box), "do-quit", GINT_TO_POINTER (do_quit)); g_signal_connect_object (images, "add", G_CALLBACK (quit_close_all_dialog_container_changed), box, 0); g_signal_connect_object (images, "remove", G_CALLBACK (quit_close_all_dialog_container_changed), box, 0); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); view_size = gimp->config->layer_preview_size; rows = CLAMP (gimp_container_get_n_children (images), 3, 6); view = gimp_container_tree_view_new (images, context, view_size, 1); gimp_container_box_set_size_request (GIMP_CONTAINER_BOX (view), -1, rows * (view_size + 2)); gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0); gtk_widget_show (view); g_signal_connect (view, "activate-item", G_CALLBACK (quit_close_all_dialog_image_activated), gimp); dnd_widget = gimp_container_view_get_dnd_widget (GIMP_CONTAINER_VIEW (view)); gimp_dnd_xds_source_add (dnd_widget, (GimpDndDragViewableFunc) gimp_dnd_get_drag_data, NULL); if (do_quit) label = gtk_label_new (_("If you quit GIMP now, " "these changes will be lost.")); else label = gtk_label_new (_("If you close these images now, " "changes will be lost.")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_widget_show (label); g_object_set_data (G_OBJECT (box), "lost-label", label); quit_close_all_dialog_container_changed (images, NULL, GIMP_MESSAGE_DIALOG (dialog)->box); return dialog; }
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_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); 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_get_content_area (GTK_DIALOG (dialog))), 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; }
uint8_t DIA_job(uint32_t nb, char **name) { GtkListStore *store; GtkTreeViewColumn *column,*column2,*column3; GtkCellRenderer *renderer; int ret=0; GtkWidget *dialog; dialog=create_dialog1(); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_register_dialog(dialog); store=gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING,G_TYPE_STRING); // initialize our job structure jobs.dialog=dialog; jobs.nb=nb; jobs.name=name; jobs.status=new ADM_Job_Descriptor[nb]; jobs.store=store; memset(jobs.status,0,jobs.nb*sizeof(ADM_Job_Descriptor)); gtk_tree_view_set_model(GTK_TREE_VIEW(WID(treeview1)),GTK_TREE_MODEL (store)); gtk_tree_view_columns_autosize(GTK_TREE_VIEW(WID(treeview1))); // Add columns renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (QT_TR_NOOP(" Job Name "), renderer, "markup", (GdkModifierType) 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (WID(treeview1)), column); column2 = gtk_tree_view_column_new_with_attributes (QT_TR_NOOP("Started at"), renderer, "markup", (GdkModifierType) 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (WID(treeview1)), column2); column3 = gtk_tree_view_column_new_with_attributes (QT_TR_NOOP("Finished at"), renderer, "markup", (GdkModifierType) 2, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (WID(treeview1)), column3); // #define ASSOCIATE(x,y) gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(x),y) ASSOCIATE(buttonDelete,COMMAND_DELETE); ASSOCIATE(buttonDeleteAll,COMMAND_DELETE_ALL); ASSOCIATE(buttonRunAll,COMMAND_RUN_ALL); ASSOCIATE(buttonRun,COMMAND_RUN); // int running=1; gtk_widget_set_usize(WID(treeview1), 180, 300); while(running) { int sel=0,event; updateStatus(); switch(event=gtk_dialog_run(GTK_DIALOG(dialog))) { case GTK_RESPONSE_OK : running=0;break; case GTK_RESPONSE_APPLY : running=0;break; case GTK_RESPONSE_CANCEL : case GTK_RESPONSE_DELETE_EVENT: running=0;break; case COMMAND_DELETE_ALL: if(GUI_Confirmation_HIG(QT_TR_NOOP("Sure!"),QT_TR_NOOP("Delete ALL jobs"),QT_TR_NOOP("Are you sure you want to delete all jobs ?"))) { for(int i=0;i<jobs.nb;i++) jobs.status[i].status=STATUS_DELETED; } break; case COMMAND_RUN: sel=getSelection(jobs.dialog); if(sel>=jobs.nb) break; jobs.status[sel].status=STATUS_RUNNING; updateStatus(); GUI_Quiet(); TLK_getDate(&(jobs.status[sel].startDate)); if(parseECMAScript(jobs.name[sel])) jobs.status[sel].status=STATUS_SUCCEED; else jobs.status[sel].status=STATUS_FAILED; TLK_getDate(&(jobs.status[sel].endDate)); updateStatus(); GUI_Verbose(); break; case COMMAND_RUN_ALL: GUI_Quiet(); for(int i=0;i<jobs.nb;i++) { if(jobs.status[i].status==STATUS_DELETED) continue; if(jobs.status[i].status==STATUS_SUCCEED) continue; jobs.status[i].status=STATUS_RUNNING; TLK_getDate(&(jobs.status[i].startDate)); updateStatus(); if(parseECMAScript(jobs.name[i])) jobs.status[i].status=STATUS_SUCCEED; else jobs.status[i].status=STATUS_FAILED; TLK_getDate(&(jobs.status[i].endDate)); } updateStatus(); GUI_Verbose(); break; case COMMAND_DELETE: sel=getSelection(jobs.dialog); if(sel>=jobs.nb) break; if(GUI_Confirmation_HIG(QT_TR_NOOP("Sure!"),QT_TR_NOOP("Delete job"),QT_TR_NOOP("Are you sure you want to delete %s job ?"),ADM_GetFileName(jobs.name[sel]))) { jobs.status[sel].status=STATUS_DELETED; } break; default: printf("Event:%d\n",event); GUI_Error_HIG("Jobs",QT_TR_NOOP("Unknown event"));break; } } gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); // Now delete the "deleted" jobs for(int i=0;i<jobs.nb;i++) { if(jobs.status[i].status==STATUS_DELETED) { unlink(jobs.name[i]); } } delete [] jobs.status; return ret; }
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 (dlg)->vbox), 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 gboolean lens_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *label; GtkWidget *toggle; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *spinbutton; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Lens 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)); 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_aspect_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 (drawlens), drawable); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); toggle = gtk_radio_button_new_with_mnemonic_from_widget (NULL, _("_Keep original surroundings")); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), lvals.keep_surr); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &lvals.keep_surr); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (toggle), gimp_drawable_is_indexed (drawable->drawable_id) ? _("_Set surroundings to index 0") : _("_Set surroundings to background color")); gtk_box_pack_start(GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), lvals.use_bkgr); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &lvals.use_bkgr); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); if (gimp_drawable_has_alpha (drawable->drawable_id)) { toggle = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (toggle), _("_Make surroundings transparent")); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), lvals.set_transparent); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &lvals.set_transparent); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); } hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Lens refraction index:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&adj, lvals.refraction, 1.0, 100.0, 0.1, 1.0, 0, 1, 2); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &lvals.refraction); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (hbox); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
void file_revert_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; GtkWidget *dialog; const gchar *uri; return_if_no_display (display, data); image = gimp_display_get_image (display); uri = gimp_image_get_uri (image); if (! uri) uri = gimp_image_get_imported_uri (image); dialog = g_object_get_data (G_OBJECT (image), REVERT_DATA_KEY); if (! uri) { gimp_message_literal (image->gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR, _("Revert failed. " "No file name associated with this image.")); } else if (dialog) { gtk_window_present (GTK_WINDOW (dialog)); } else { gchar *filename; dialog = gimp_message_dialog_new (_("Revert Image"), GTK_STOCK_REVERT_TO_SAVED, GTK_WIDGET (gimp_display_get_shell (display)), 0, gimp_standard_help_func, GIMP_HELP_FILE_REVERT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_REVERT_TO_SAVED, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect_object (display, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); g_signal_connect (dialog, "response", G_CALLBACK (file_revert_confirm_response), display); filename = file_utils_uri_display_name (uri); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Revert '%s' to '%s'?"), gimp_image_get_display_name (image), filename); g_free (filename); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("By reverting the image to the state saved " "on disk, you will lose all changes, " "including all undo information.")); g_object_set_data (G_OBJECT (image), REVERT_DATA_KEY, dialog); gtk_widget_show (dialog); } }
/*! \brief Opens a file chooser for saving the current page. * \par Function Description * This function opens a file chooser dialog and wait for the user to * select a file where the <B>toplevel</B>'s current page will be * saved. * * If the user cancels the operation (with the cancel button), the * page is not saved. * * The function updates the user interface. * * \param [in] w_current The GSCHEM_TOPLEVEL environment. */ void x_fileselect_save (GSCHEM_TOPLEVEL *w_current) { TOPLEVEL *toplevel = w_current->toplevel; GtkWidget *dialog; dialog = gtk_file_chooser_dialog_new (_("Save as..."), GTK_WINDOW(w_current->main_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); /* set default response signal. This is usually triggered by the "Return" key */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); g_object_set (dialog, /* GtkFileChooser */ "select-multiple", FALSE, /* only in GTK 2.8 */ /* "do-overwrite-confirmation", TRUE, */ NULL); /* add file filters to dialog */ x_fileselect_setup_filechooser_filters (GTK_FILE_CHOOSER (dialog)); /* set the current filename or directory name if new document */ if ((toplevel->page_current->page_filename != NULL) && g_file_test (toplevel->page_current->page_filename, G_FILE_TEST_EXISTS)) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), toplevel->page_current->page_filename); } else { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "untitled.sch"); } gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); gtk_widget_show (dialog); if (gtk_dialog_run ((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT) { gchar *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); /* If the file already exists, display a dialog box to check if the user really wants to overwrite it. */ if ((filename != NULL) && g_file_test (filename, G_FILE_TEST_EXISTS)) { GtkWidget *checkdialog = gtk_message_dialog_new (GTK_WINDOW(dialog), (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("The selected file `%s' already exists.\n\n" "Would you like to overwrite it?"), filename); gtk_window_set_title (GTK_WINDOW (checkdialog), _("Overwrite file?")); if (gtk_dialog_run (GTK_DIALOG (checkdialog)) != GTK_RESPONSE_YES) { s_log_message (_("Save cancelled on user request\n")); g_free (filename); filename = NULL; } gtk_widget_destroy (checkdialog); } /* try saving current page of toplevel to file filename */ if (filename != NULL) { x_window_save_page (w_current, w_current->toplevel->page_current, filename); } g_free (filename); } gtk_widget_destroy (dialog); }
static gboolean sharpen_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Sharpen"), 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 (preview_update), NULL); 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), 0, 0, _("_Sharpness:"), SCALE_WIDTH, 0, sharpen_params.sharpen_percent, 1, 99, 1, 10, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &sharpen_params.sharpen_percent); 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; }
/* ---------------------------------------------- */ gint ghid_dialog_close_confirm () { GtkWidget *dialog; gint rv; GHidPort *out = &ghid_port; gchar *tmp; gchar *str; if (PCB->Filename == NULL) { tmp = g_strdup_printf ( _("Save the changes to layout before closing?")); } else { tmp = g_strdup_printf ( _("Save the changes to layout \"%s\" before closing?"), PCB->Filename); } str = g_strconcat ("<big><b>", tmp, "</b></big>", NULL); g_free (tmp); tmp = _("If you don't save, all your changes will be permanently lost."); str = g_strconcat (str, "\n\n", tmp, NULL); dialog = gtk_message_dialog_new (GTK_WINDOW (out->top_window), (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, NULL); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), str); gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("Close _without saving"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_YES, NULL); /* Set the alternative button order (ok, cancel, help) for other systems */ gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_YES, GTK_RESPONSE_NO, GTK_RESPONSE_CANCEL, -1); switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_NO: { rv = GUI_DIALOG_CLOSE_CONFIRM_NOSAVE; break; } case GTK_RESPONSE_YES: { rv = GUI_DIALOG_CLOSE_CONFIRM_SAVE; break; } case GTK_RESPONSE_CANCEL: default: { rv = GUI_DIALOG_CLOSE_CONFIRM_CANCEL; break; } } gtk_widget_destroy (dialog); return rv; }
/* * create a generic query box without any entry widget */ static QueryBox * create_query_box (const gchar *title, GtkWidget *parent, GimpHelpFunc help_func, const gchar *help_id, GCallback response_callback, const gchar *icon_name, const gchar *message, const gchar *ok_button, const gchar *cancel_button, GObject *object, const gchar *signal, GCallback callback, gpointer callback_data) { QueryBox *query_box; GtkWidget *hbox = NULL; GtkWidget *label; /* make sure the object / signal passed are valid */ g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (object == NULL || G_IS_OBJECT (object), NULL); g_return_val_if_fail (object == NULL || signal != NULL, NULL); query_box = g_slice_new0 (QueryBox); query_box->qbox = gimp_dialog_new (title, "gimp-query-box", parent, 0, help_func, help_id, cancel_button, GTK_RESPONSE_CANCEL, ok_button, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (query_box->qbox), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); query_box->response_handler = g_signal_connect (query_box->qbox, "response", G_CALLBACK (response_callback), query_box); g_signal_connect (query_box->qbox, "destroy", G_CALLBACK (gtk_widget_destroyed), &query_box->qbox); /* if we are associated with an object, connect to the provided signal */ if (object) { GClosure *closure; closure = g_cclosure_new_swap (G_CALLBACK (query_box_cancel_callback), query_box, NULL); g_object_watch_closure (G_OBJECT (query_box->qbox), closure); g_signal_connect_closure (object, signal, closure, FALSE); } if (icon_name) { GtkWidget *content_area; GtkWidget *image; content_area = gtk_dialog_get_content_area (GTK_DIALOG (query_box->qbox)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); } query_box->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); g_object_set_data (G_OBJECT (query_box->qbox), "gimp-query-box-vbox", query_box->vbox); if (hbox) { gtk_box_pack_start (GTK_BOX (hbox), query_box->vbox, FALSE, FALSE, 0); } else { GtkWidget *content_area; content_area = gtk_dialog_get_content_area (GTK_DIALOG (query_box->qbox)); gtk_container_set_border_width (GTK_CONTAINER (query_box->vbox), 12); gtk_box_pack_start (GTK_BOX (content_area), query_box->vbox, TRUE, TRUE, 0); } gtk_widget_show (query_box->vbox); if (message) { label = gtk_label_new (message); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (query_box->vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); } query_box->entry = NULL; query_box->object = object; query_box->callback = callback; query_box->callback_data = callback_data; return query_box; }
static gboolean shift_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *size_entry; GtkWidget *vertical; GtkWidget *horizontal; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Shift"), 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 (shift), drawable); frame = gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (gimp_radio_button_update), &shvals.orientation, shvals.orientation, _("Shift _horizontally"), HORIZONTAL, &horizontal, _("Shift _vertically"), VERTICAL, &vertical, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 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); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); size_entry = gimp_size_entry_new (1, unit, "%a", TRUE, FALSE, FALSE, SPIN_BUTTON_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (size_entry), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (size_entry), 0, xres, TRUE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (size_entry), 0, 1.0, 200.0); gtk_table_set_col_spacing (GTK_TABLE (size_entry), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (size_entry), 2, 12); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (size_entry), 0, (gdouble) shvals.shift_amount); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (size_entry), _("Shift _amount:"), 1, 0, 0.0); g_signal_connect (size_entry, "value-changed", G_CALLBACK (shift_amount_callback), preview); gtk_box_pack_start (GTK_BOX (main_vbox), size_entry, FALSE, FALSE, 0); gtk_widget_show (size_entry); 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; GdkPixbuf *preview; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkWidget *toggle; GtkWidget *toggle2; GtkObject *adj; gboolean run; GError *error = NULL; SvgLoadVals vals = { SVG_DEFAULT_RESOLUTION, - SVG_PREVIEW_SIZE, - SVG_PREVIEW_SIZE }; preview = load_rsvg_pixbuf (filename, &vals, &error); if (!preview) { /* Do not rely on librsvg setting GError on failure! */ g_message (_("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), error ? error->message : _("Unknown reason")); return FALSE; } gimp_ui_init (PLUG_IN_BINARY, FALSE); /* Scalable Vector Graphics is SVG, should perhaps not be translated */ dialog = gimp_dialog_new (_("Render Scalable Vector Graphics"), 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 (dialog)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The SVG 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); image = gtk_image_new_from_pixbuf (preview); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); 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_rsvg_size (filename, &vals, NULL); svg_width = vals.width; svg_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, 1, 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, svg_width); gimp_size_entry_set_refval (size, 1, svg_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) svg_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_width, 0.01, 0.1, 1, 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) svg_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_height, 0.01, 0.1, 1, 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, librsvg tends 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); /* Path Import */ toggle = gtk_check_button_new_with_mnemonic (_("Import _paths")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 5, 6, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Import path elements of the SVG so they " "can be used with the GIMP path tool"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), load_vals.import); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.import); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_sensitive_update), NULL); toggle2 = gtk_check_button_new_with_mnemonic (_("Merge imported paths")); gtk_table_attach (GTK_TABLE (table), toggle2, 0, 2, 6, 7, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_set_sensitive (toggle2, load_vals.import); gtk_widget_show (toggle2); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle2), load_vals.merge); g_signal_connect (toggle2, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.merge); g_object_set_data (G_OBJECT (toggle), "set_sensitive", toggle2); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); } gtk_widget_destroy (dialog); return run; }
static gboolean retinex_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *table; GtkWidget *combo; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Retinex Image Enhancement"), 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 (retinex), drawable); table = gtk_table_new (4, 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); combo = gimp_int_combo_box_new (_("Uniform"), filter_uniform, _("Low"), filter_low, _("High"), filter_high, NULL); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), rvals.scales_mode, G_CALLBACK (gimp_int_combo_box_get_active), &rvals.scales_mode); g_signal_connect_swapped (combo, "changed", G_CALLBACK (gimp_preview_invalidate), preview); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Level:"), 0.0, 0.5, combo, 2, FALSE); gtk_widget_show (combo); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Scale:"), SCALE_WIDTH, ENTRY_WIDTH, rvals.scale, MIN_GAUSSIAN_SCALE, MAX_GAUSSIAN_SCALE, 1, 1, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &rvals.scale); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Scale _division:"), SCALE_WIDTH, ENTRY_WIDTH, rvals.nscales, 0, MAX_RETINEX_SCALES, 1, 1, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &rvals.nscales); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("Dy_namic:"), SCALE_WIDTH, ENTRY_WIDTH, rvals.cvar, 0, 4, 0.1, 0.1, 1, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_float_adjustment_update), &rvals.cvar); 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; }