static WidgetInfo * create_color_button (void) { GtkWidget *vbox; GtkWidget *button; GtkWidget *align; GimpRGB color; color_init (&color); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); align = gtk_alignment_new (0.5, 0.5, 0.5, 1.0); button = gimp_color_button_new ("Color Button", 80, 20, &color, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_container_add (GTK_CONTAINER (align), button); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Color Button"), FALSE, FALSE, 0); return new_widget_info ("gimp-widget-color-button", vbox, SMALL); }
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); }
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; }
void create_generalpage (GtkNotebook *notebook) { GtkWidget *box1, *box2, *box3, *box4, *thispage; GtkWidget *label, *tmpw, *frame, *table; GSList * radio_group = NULL; label = gtk_label_new_with_mnemonic (_("_General")); thispage = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (thispage), 12); gtk_widget_show (thispage); frame = gimp_frame_new (_("Background")); gtk_box_pack_start (GTK_BOX (thispage), frame, FALSE, FALSE, 0); gtk_widget_show (frame); box3 = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), box3); gtk_widget_show (box3); create_general_button (box3, BG_TYPE_KEEP_ORIGINAL, _("Keep original"), _("Preserve the original image as a background"), &radio_group); create_general_button (box3, BG_TYPE_FROM_PAPER, _("From paper"), _("Copy the texture of the selected paper as a background"), &radio_group); box4 = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (box3), box4, FALSE, FALSE, 0); gtk_widget_show (box4); create_general_button (box4, BG_TYPE_SOLID, _("Solid"), _("Solid colored background"), &radio_group); general_color_button = gimp_color_button_new (_("Color"), COLORBUTTONWIDTH, COLORBUTTONHEIGHT, &pcvals.color, GIMP_COLOR_AREA_FLAT); g_signal_connect (general_color_button, "clicked", G_CALLBACK (select_color), NULL); g_signal_connect (general_color_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &pcvals.color); gtk_box_pack_start (GTK_BOX (box4), general_color_button, FALSE, FALSE, 0); gtk_widget_show (general_color_button); tmpw = create_general_button (box3, BG_TYPE_TRANSPARENT, _("Transparent"), _("Use a transparent background; Only the strokes painted will be visible"), &radio_group); if (!img_has_alpha) gtk_widget_set_sensitive (tmpw, FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (general_bg_radio[pcvals.general_background_type]), TRUE); box1 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (thispage), box1, FALSE, FALSE, 0); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_widget_show (box2); tmpw = gtk_check_button_new_with_label ( _("Paint edges")); general_paint_edges = tmpw; gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gimp_help_set_help_data (tmpw, _("Selects if to place strokes all the way out to the edges of the image"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.general_paint_edges); general_tileable = tmpw = gtk_check_button_new_with_label ( _("Tileable")); gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gimp_help_set_help_data (tmpw, _("Selects if the resulting image should be seamlessly tileable"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.general_tileable); tmpw = gtk_check_button_new_with_label ( _("Drop shadow")); general_drop_shadow = tmpw; gtk_box_pack_start (GTK_BOX (box2), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); gimp_help_set_help_data (tmpw, _("Adds a shadow effect to each brush stroke"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.general_drop_shadow); 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 (box1), table, FALSE, FALSE, 0); gtk_widget_show (table); general_dark_edge_adjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Edge darken:"), 150, 6, pcvals.general_dark_edge, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, _("How much to \"darken\" the edges of each brush stroke"), NULL); general_shadow_adjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("Shadow darken:"), 150, 6, pcvals.general_shadow_darkness, 0.0, 99.0, 0.1, 1, 2, TRUE, 0, 0, _("How much to \"darken\" the drop shadow"), NULL); general_shadow_depth = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Shadow depth:"), 150, 6, pcvals.general_shadow_depth, 0, 99, 1, 5, 0, TRUE, 0, 0, _("The depth of the drop shadow, i.e. how far apart from the object it should be"), NULL); general_shadow_blur = gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("Shadow blur:"), 150, 6, pcvals.general_shadow_blur, 0, 99, 1, 5, 0, TRUE, 0, 0, _("How much to blur the drop shadow"), NULL); dev_thresh_adjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 4, _("Deviation threshold:"), 150, 6, pcvals.devthresh, 0.0, 1.0, 0.01, 0.01, 2, TRUE, 0, 0, _("A bailout-value for adaptive selections"), NULL); gtk_notebook_append_page_menu (notebook, thispage, label, NULL); }
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_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 (color_to_alpha_preview), drawable); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (C_("color-to-alpha", "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; }
/* 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; }
static gboolean colorify_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *label; GtkWidget *button; GtkWidget *table; GtkWidget *color_area; gint i; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); dialog = gimp_dialog_new (_("Colorify"), 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_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (colorify), drawable); table = gtk_table_new (2, 7, TRUE); 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); label = gtk_label_new (_("Custom color:")); gtk_table_attach (GTK_TABLE (table), label, 4, 6, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); custom_color_button = gimp_color_button_new (_("Colorify Custom Color"), COLOR_SIZE, COLOR_SIZE, &cvals.color, GIMP_COLOR_AREA_FLAT); g_signal_connect (custom_color_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &cvals.color); g_signal_connect_swapped (custom_color_button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_table_attach (GTK_TABLE (table), custom_color_button, 6, 7, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (custom_color_button); for (i = 0; i < 7; i++) { button = gtk_button_new (); color_area = gimp_color_area_new (&button_color[i], GIMP_COLOR_AREA_FLAT, GDK_BUTTON2_MASK); gtk_widget_set_size_request (GTK_WIDGET (color_area), COLOR_SIZE, COLOR_SIZE); gtk_container_add (GTK_CONTAINER (button), color_area); g_signal_connect (button, "clicked", G_CALLBACK (predefined_color_callback), &button_color[i]); gtk_widget_show (color_area); gtk_table_attach (GTK_TABLE (table), button, i, i + 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (button); } gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gint dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dlg; GtkWidget *main_vbox; GtkWidget *vbox; GtkSizeGroup *group; GtkWidget *label; GtkWidget *preview; GtkWidget *button; GtkWidget *width; GtkWidget *space; GtkWidget *offset; GtkWidget *chain_button; GtkWidget *table; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; g_return_val_if_fail (main_dialog == NULL, FALSE); gimp_ui_init (PLUG_IN_BINARY, TRUE); main_dialog = dlg = gimp_dialog_new (_("Grid"), 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 (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); 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); 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 (update_preview), drawable); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /* The width entries */ width = gimp_size_entry_new (3, /* number_of_fields */ unit, /* unit */ "%a", /* unit_format */ TRUE, /* menu_show_pixels */ TRUE, /* menu_show_percent */ FALSE, /* show_refval */ SPIN_BUTTON_WIDTH, /* spinbutton_usize */ GIMP_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */ gtk_box_pack_start (GTK_BOX (vbox), width, FALSE, FALSE, 0); gtk_widget_show (width); /* set the unit back to pixels, since most times we will want pixels */ gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (width), GIMP_UNIT_PIXEL); /* set the resolution to the image resolution */ gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (width), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (width), 1, yres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (width), 2, xres, TRUE); /* set the size (in pixels) that will be treated as 0% and 100% */ gimp_size_entry_set_size (GIMP_SIZE_ENTRY (width), 0, 0.0, drawable->height); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (width), 1, 0.0, drawable->width); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (width), 2, 0.0, drawable->width); /* set upper and lower limits (in pixels) */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (width), 0, 0.0, drawable->height); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (width), 1, 0.0, drawable->width); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (width), 2, 0.0, MAX (drawable->width, drawable->height)); gtk_table_set_row_spacing (GTK_TABLE (width), 0, 6); gtk_table_set_col_spacings (GTK_TABLE (width), 6); gtk_table_set_col_spacing (GTK_TABLE (width), 2, 12); /* initialize the values */ gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (width), 0, grid_cfg.hwidth); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (width), 1, grid_cfg.vwidth); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (width), 2, grid_cfg.iwidth); /* attach labels */ gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Horizontal\nLines"), 0, 1, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Vertical\nLines"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Intersection"), 0, 3, 0.0); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Width:"), 1, 0, 0.0); group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (group, label); g_object_unref (group); /* put a chain_button under the size_entries */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (grid_cfg.hwidth == grid_cfg.vwidth) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (width), chain_button, 1, 3, 2, 3); gtk_widget_show (chain_button); /* connect to the 'value-changed' signal because we have to take care * of keeping the entries in sync when the chainbutton is active */ g_signal_connect (width, "value-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect_swapped (width, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* The spacing entries */ space = gimp_size_entry_new (3, /* number_of_fields */ unit, /* unit */ "%a", /* unit_format */ TRUE, /* menu_show_pixels */ TRUE, /* menu_show_percent */ FALSE, /* show_refval */ SPIN_BUTTON_WIDTH, /* spinbutton_usize */ GIMP_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */ gtk_box_pack_start (GTK_BOX (vbox), space, FALSE, FALSE, 0); gtk_widget_show (space); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (space), GIMP_UNIT_PIXEL); /* set the resolution to the image resolution */ gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (space), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (space), 1, yres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (space), 2, xres, TRUE); /* set the size (in pixels) that will be treated as 0% and 100% */ gimp_size_entry_set_size (GIMP_SIZE_ENTRY (space), 0, 0.0, drawable->height); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (space), 1, 0.0, drawable->width); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (space), 2, 0.0, drawable->width); /* set upper and lower limits (in pixels) */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (space), 0, 1.0, drawable->height); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (space), 1, 1.0, drawable->width); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (space), 2, 0.0, MAX (drawable->width, drawable->height)); gtk_table_set_col_spacings (GTK_TABLE (space), 6); gtk_table_set_col_spacing (GTK_TABLE (space), 2, 12); /* initialize the values */ gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (space), 0, grid_cfg.hspace); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (space), 1, grid_cfg.vspace); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (space), 2, grid_cfg.ispace); /* attach labels */ label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (space), _("Spacing:"), 1, 0, 0.0); gtk_size_group_add_widget (group, label); /* put a chain_button under the spacing_entries */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (grid_cfg.hspace == grid_cfg.vspace) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (space), chain_button, 1, 3, 2, 3); gtk_widget_show (chain_button); /* connect to the 'value-changed' and "unit-changed" signals because * we have to take care of keeping the entries in sync when the * chainbutton is active */ g_signal_connect (space, "value-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect (space, "unit-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect_swapped (space, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* The offset entries */ offset = gimp_size_entry_new (3, /* number_of_fields */ unit, /* unit */ "%a", /* unit_format */ TRUE, /* menu_show_pixels */ TRUE, /* menu_show_percent */ FALSE, /* show_refval */ SPIN_BUTTON_WIDTH, /* spinbutton_usize */ GIMP_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */ gtk_box_pack_start (GTK_BOX (vbox), offset, FALSE, FALSE, 0); gtk_widget_show (offset); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (offset), GIMP_UNIT_PIXEL); /* set the resolution to the image resolution */ gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (offset), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (offset), 1, yres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (offset), 2, xres, TRUE); /* set the size (in pixels) that will be treated as 0% and 100% */ gimp_size_entry_set_size (GIMP_SIZE_ENTRY (offset), 0, 0.0, drawable->height); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (offset), 1, 0.0, drawable->width); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (offset), 2, 0.0, drawable->width); /* set upper and lower limits (in pixels) */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (offset), 0, 0.0, drawable->height); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (offset), 1, 0.0, drawable->width); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (offset), 2, 0.0, MAX (drawable->width, drawable->height)); gtk_table_set_col_spacings (GTK_TABLE (offset), 6); gtk_table_set_col_spacing (GTK_TABLE (offset), 2, 12); /* initialize the values */ gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (offset), 0, grid_cfg.hoffset); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (offset), 1, grid_cfg.voffset); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (offset), 2, grid_cfg.ioffset); /* attach labels */ label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (offset), _("Offset:"), 1, 0, 0.0); gtk_size_group_add_widget (group, label); /* this is a weird hack: we put a table into the offset table */ table = gtk_table_new (3, 3, FALSE); gtk_table_attach_defaults (GTK_TABLE (offset), table, 1, 4, 2, 3); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 10); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12); /* put a chain_button under the offset_entries */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (grid_cfg.hoffset == grid_cfg.voffset) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), chain_button, 0, 2, 0, 1); gtk_widget_show (chain_button); /* connect to the 'value-changed' and "unit-changed" signals because * we have to take care of keeping the entries in sync when the * chainbutton is active */ g_signal_connect (offset, "value-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect (offset, "unit-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect_swapped (offset, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* put a chain_button under the color_buttons */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (gimp_rgba_distance (&grid_cfg.hcolor, &grid_cfg.vcolor) < 0.0001) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), chain_button, 0, 2, 2, 3); gtk_widget_show (chain_button); /* attach color selectors */ hcolor_button = gimp_color_button_new (_("Horizontal Color"), COLOR_BUTTON_WIDTH, 16, &grid_cfg.hcolor, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (hcolor_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), hcolor_button, 0, 1, 1, 2); gtk_widget_show (hcolor_button); g_signal_connect (hcolor_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &grid_cfg.hcolor); g_signal_connect (hcolor_button, "color-changed", G_CALLBACK (color_callback), chain_button); g_signal_connect_swapped (hcolor_button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); vcolor_button = gimp_color_button_new (_("Vertical Color"), COLOR_BUTTON_WIDTH, 16, &grid_cfg.vcolor, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (vcolor_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), vcolor_button, 1, 2, 1, 2); gtk_widget_show (vcolor_button); g_signal_connect (vcolor_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &grid_cfg.vcolor); g_signal_connect (vcolor_button, "color-changed", G_CALLBACK (color_callback), chain_button); g_signal_connect_swapped (vcolor_button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); button = gimp_color_button_new (_("Intersection Color"), COLOR_BUTTON_WIDTH, 16, &grid_cfg.icolor, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 1, 2); gtk_widget_show (button); g_signal_connect (button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &grid_cfg.icolor); g_signal_connect_swapped (button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (table); gtk_widget_show (dlg); g_object_set_data (G_OBJECT (dlg), "width", width); g_object_set_data (G_OBJECT (dlg), "space", space); g_object_set_data (G_OBJECT (dlg), "offset", offset); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); if (run) update_values (); gtk_widget_destroy (dlg); return run; }
static void create_selection_tab (GtkWidget *notebook, gint32 image_ID) { GtkSizeGroup *group; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *table; GtkWidget *label; GtkWidget *frame; GtkWidget *toggle; GtkWidget *spinbutton; GtkAdjustment *adj; GtkWidget *button; GtkWidget *font_button; gint32 *image_id_list; gint nimages, j; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, gtk_label_new_with_mnemonic (_("Selection"))); gtk_widget_show (hbox); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* Film height/color */ frame = gimp_frame_new (_("Filmstrip")); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* Keep maximum image height */ toggle = gtk_check_button_new_with_mnemonic (_("_Fit height to images")); 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), &filmvals.keep_height); table = gtk_table_new (2, 2, 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 (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Film height */ adj = GTK_ADJUSTMENT (gtk_adjustment_new (filmvals.film_height, 10, GIMP_MAX_IMAGE_SIZE, 1, 10, 0)); spinbutton = gtk_spin_button_new (adj, 1, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Height:"), 0.0, 0.5, spinbutton, 1, TRUE); gtk_size_group_add_widget (group, label); g_object_unref (group); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &filmvals.film_height); g_object_bind_property (toggle, "active", spinbutton, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_object_bind_property (toggle, "active", /* FIXME: eeeeeek */ g_list_nth_data (gtk_container_get_children (GTK_CONTAINER (table)), 1), "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), filmvals.keep_height); /* Film color */ button = gimp_color_button_new (_("Select Film Color"), COLOR_BUTTON_WIDTH, COLOR_BUTTON_HEIGHT, &filmvals.film_color, GIMP_COLOR_AREA_FLAT); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("Co_lor:"), 0.0, 0.5, button, 1, FALSE); gtk_size_group_add_widget (group, label); g_signal_connect (button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &filmvals.film_color); /* Film numbering: Startindex/Font/color */ frame = gimp_frame_new (_("Numbering")); gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); table = gtk_table_new (3, 2, 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 (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* Startindex */ adj = GTK_ADJUSTMENT (gtk_adjustment_new (filmvals.number_start, 0, GIMP_MAX_IMAGE_SIZE, 1, 10, 0)); spinbutton = gtk_spin_button_new (adj, 1, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Start _index:"), 0.0, 0.5, spinbutton, 1, TRUE); gtk_size_group_add_widget (group, label); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &filmvals.number_start); /* Fontfamily for numbering */ font_button = gimp_font_select_button_new (NULL, filmvals.number_font); g_signal_connect (font_button, "font-set", G_CALLBACK (film_font_select_callback), &filmvals); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("_Font:"), 0.0, 0.5, font_button, 1, FALSE); gtk_size_group_add_widget (group, label); /* Numbering color */ button = gimp_color_button_new (_("Select Number Color"), COLOR_BUTTON_WIDTH, COLOR_BUTTON_HEIGHT, &filmvals.number_color, GIMP_COLOR_AREA_FLAT); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Co_lor:"), 0.0, 0.5, button, 1, FALSE); gtk_size_group_add_widget (group, label); g_signal_connect (button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &filmvals.number_color); for (j = 0; j < 2; j++) { toggle = gtk_check_button_new_with_mnemonic (j ? _("At _bottom") : _("At _top")); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), filmvals.number_pos[j]); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &filmvals.number_pos[j]); } /*** The right frame keeps the image selection ***/ frame = gimp_frame_new (_("Image Selection")); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE); gtk_container_add (GTK_CONTAINER (frame), hbox); /* Get a list of all image names */ image_id_list = gimp_image_list (&nimages); filmint.image_list_all = add_image_list (TRUE, nimages, image_id_list, hbox); /* Get a list of the images used for the film */ filmint.image_list_film = add_image_list (FALSE, 1, &image_ID, hbox); gtk_widget_show (hbox); }
GimpPDBStatusType script_fu_interface (SFScript *script, gint start_arg) { GtkWidget *dialog; GtkWidget *menu; GtkWidget *vbox; GtkWidget *vbox2; GtkSizeGroup *group; GSList *list; gchar *title; gint i; static gboolean gtk_initted = FALSE; /* Simply return if there is already an interface. This is an * ugly workaround for the fact that we can not process two * scripts at a time. */ if (sf_interface != NULL) { gchar *message = g_strdup_printf ("%s\n\n%s", _("Script-Fu cannot process two scripts " "at the same time."), _("You are already running the \"%s\" script.")); g_message (message, sf_interface->title); g_free (message); return GIMP_PDB_CANCEL; } g_return_val_if_fail (script != NULL, FALSE); if (!gtk_initted) { INIT_I18N(); gimp_ui_init ("script-fu", TRUE); gtk_initted = TRUE; } sf_status = GIMP_PDB_SUCCESS; sf_interface = g_slice_new0 (SFInterface); sf_interface->widgets = g_new0 (GtkWidget *, script->n_args); sf_interface->title = script_fu_script_get_title (script); title = g_strdup_printf (_("Script-Fu: %s"), sf_interface->title); sf_interface->dialog = dialog = gimp_dialog_new (title, "script-fu", NULL, 0, gimp_standard_help_func, script->name, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_free (title); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); g_signal_connect (dialog, "response", G_CALLBACK (script_fu_response), script); g_signal_connect_swapped (dialog, "destroy", G_CALLBACK (script_fu_interface_quit), script); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* The argument table */ sf_interface->table = gtk_table_new (script->n_args - start_arg, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (sf_interface->table), 6); gtk_table_set_row_spacings (GTK_TABLE (sf_interface->table), 6); gtk_box_pack_start (GTK_BOX (vbox), sf_interface->table, FALSE, FALSE, 0); gtk_widget_show (sf_interface->table); group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); for (i = start_arg; i < script->n_args; i++) { GtkWidget *widget = NULL; GtkObject *adj; gchar *label_text; gfloat label_yalign = 0.5; gint *ID_ptr = NULL; gint row = i; gboolean left_align = FALSE; SFArg *arg = &script->args[i]; row -= start_arg; /* we add a colon after the label; * some languages want an extra space here */ label_text = g_strdup_printf (_("%s:"), gettext (arg->label)); switch (arg->type) { case SF_IMAGE: case SF_DRAWABLE: case SF_LAYER: case SF_CHANNEL: case SF_VECTORS: switch (arg->type) { case SF_IMAGE: widget = gimp_image_combo_box_new (NULL, NULL); ID_ptr = &arg->value.sfa_image; break; case SF_DRAWABLE: widget = gimp_drawable_combo_box_new (NULL, NULL); ID_ptr = &arg->value.sfa_drawable; break; case SF_LAYER: widget = gimp_layer_combo_box_new (NULL, NULL); ID_ptr = &arg->value.sfa_layer; break; case SF_CHANNEL: widget = gimp_channel_combo_box_new (NULL, NULL); ID_ptr = &arg->value.sfa_channel; break; case SF_VECTORS: widget = gimp_vectors_combo_box_new (NULL, NULL); ID_ptr = &arg->value.sfa_vectors; break; default: menu = NULL; break; } gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (widget), *ID_ptr, G_CALLBACK (gimp_int_combo_box_get_active), ID_ptr); break; case SF_COLOR: left_align = TRUE; widget = gimp_color_button_new (_("Script-Fu Color Selection"), COLOR_SAMPLE_WIDTH, COLOR_SAMPLE_HEIGHT, &arg->value.sfa_color, GIMP_COLOR_AREA_FLAT); gimp_color_button_set_update (GIMP_COLOR_BUTTON (widget), TRUE); g_signal_connect (widget, "color-changed", G_CALLBACK (gimp_color_button_get_color), &arg->value.sfa_color); break; case SF_TOGGLE: g_free (label_text); label_text = NULL; widget = gtk_check_button_new_with_mnemonic (gettext (arg->label)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), arg->value.sfa_toggle); g_signal_connect (widget, "toggled", G_CALLBACK (gimp_toggle_button_update), &arg->value.sfa_toggle); break; case SF_VALUE: case SF_STRING: widget = gtk_entry_new (); gtk_widget_set_size_request (widget, TEXT_WIDTH, -1); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); gtk_entry_set_text (GTK_ENTRY (widget), arg->value.sfa_value); break; case SF_TEXT: { GtkWidget *view; GtkTextBuffer *buffer; widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (widget, TEXT_WIDTH, -1); view = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (widget), view); gtk_widget_show (view); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); gtk_text_view_set_editable (GTK_TEXT_VIEW (view), TRUE); gtk_text_buffer_set_text (buffer, arg->value.sfa_value, -1); label_yalign = 0.0; } break; case SF_ADJUSTMENT: switch (arg->default_value.sfa_adjustment.type) { case SF_SLIDER: arg->value.sfa_adjustment.adj = (GtkAdjustment *) gimp_scale_entry_new (GTK_TABLE (sf_interface->table), 0, row, label_text, SLIDER_WIDTH, -1, arg->value.sfa_adjustment.value, arg->default_value.sfa_adjustment.lower, arg->default_value.sfa_adjustment.upper, arg->default_value.sfa_adjustment.step, arg->default_value.sfa_adjustment.page, arg->default_value.sfa_adjustment.digits, TRUE, 0.0, 0.0, NULL, NULL); gtk_entry_set_activates_default (GIMP_SCALE_ENTRY_SPINBUTTON (arg->value.sfa_adjustment.adj), TRUE); break; default: g_warning ("unexpected adjustment type: %d", arg->default_value.sfa_adjustment.type); /* fallthrough */ case SF_SPINNER: left_align = TRUE; widget = gimp_spin_button_new (&adj, arg->value.sfa_adjustment.value, arg->default_value.sfa_adjustment.lower, arg->default_value.sfa_adjustment.upper, arg->default_value.sfa_adjustment.step, arg->default_value.sfa_adjustment.page, 0, 0, arg->default_value.sfa_adjustment.digits); gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE); arg->value.sfa_adjustment.adj = GTK_ADJUSTMENT (adj); break; } g_signal_connect (arg->value.sfa_adjustment.adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &arg->value.sfa_adjustment.value); break; case SF_FILENAME: case SF_DIRNAME: if (arg->type == SF_FILENAME) widget = gtk_file_chooser_button_new (_("Script-Fu File Selection"), GTK_FILE_CHOOSER_ACTION_OPEN); else widget = gtk_file_chooser_button_new (_("Script-Fu Folder Selection"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if (arg->value.sfa_file.filename) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), arg->value.sfa_file.filename); g_signal_connect (widget, "selection-changed", G_CALLBACK (script_fu_file_callback), &arg->value.sfa_file); break; case SF_FONT: widget = gimp_font_select_button_new (_("Script-Fu Font Selection"), arg->value.sfa_font); g_signal_connect_swapped (widget, "font-set", G_CALLBACK (script_fu_font_callback), &arg->value.sfa_font); break; case SF_PALETTE: widget = gimp_palette_select_button_new (_("Script-Fu Palette Selection"), arg->value.sfa_palette); g_signal_connect_swapped (widget, "palette-set", G_CALLBACK (script_fu_palette_callback), &arg->value.sfa_palette); break; case SF_PATTERN: left_align = TRUE; widget = gimp_pattern_select_button_new (_("Script-Fu Pattern Selection"), arg->value.sfa_pattern); g_signal_connect_swapped (widget, "pattern-set", G_CALLBACK (script_fu_pattern_callback), &arg->value.sfa_pattern); break; case SF_GRADIENT: left_align = TRUE; widget = gimp_gradient_select_button_new (_("Script-Fu Gradient Selection"), arg->value.sfa_gradient); g_signal_connect_swapped (widget, "gradient-set", G_CALLBACK (script_fu_gradient_callback), &arg->value.sfa_gradient); break; case SF_BRUSH: left_align = TRUE; widget = gimp_brush_select_button_new (_("Script-Fu Brush Selection"), arg->value.sfa_brush.name, arg->value.sfa_brush.opacity, arg->value.sfa_brush.spacing, arg->value.sfa_brush.paint_mode); g_signal_connect_swapped (widget, "brush-set", G_CALLBACK (script_fu_brush_callback), &arg->value.sfa_brush); break; case SF_OPTION: #if GTK_CHECK_VERSION (2, 24, 0) widget = gtk_combo_box_text_new (); #else widget = gtk_combo_box_new_text (); #endif for (list = arg->default_value.sfa_option.list; list; list = g_slist_next (list)) { #if GTK_CHECK_VERSION (2, 24, 0) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), gettext (list->data)); #else gtk_combo_box_append_text (GTK_COMBO_BOX (widget), gettext (list->data)); #endif } gtk_combo_box_set_active (GTK_COMBO_BOX (widget), arg->value.sfa_option.history); g_signal_connect (widget, "changed", G_CALLBACK (script_fu_combo_callback), &arg->value.sfa_option); break; case SF_ENUM: widget = gimp_enum_combo_box_new (g_type_from_name (arg->default_value.sfa_enum.type_name)); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (widget), arg->value.sfa_enum.history); g_signal_connect (widget, "changed", G_CALLBACK (gimp_int_combo_box_get_active), &arg->value.sfa_enum.history); break; case SF_DISPLAY: break; } if (widget) { if (label_text) { gimp_table_attach_aligned (GTK_TABLE (sf_interface->table), 0, row, label_text, 0.0, label_yalign, widget, 2, left_align); g_free (label_text); } else { gtk_table_attach (GTK_TABLE (sf_interface->table), widget, 0, 3, row, row + 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (widget); } if (left_align) gtk_size_group_add_widget (group, widget); } sf_interface->widgets[i] = widget; } g_object_unref (group); /* the script progress bar */ vbox2 = gtk_vbox_new (FALSE, 6); gtk_box_pack_end (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); sf_interface->progress_bar = gimp_progress_bar_new (); gtk_box_pack_start (GTK_BOX (vbox2), sf_interface->progress_bar, FALSE, FALSE, 0); gtk_widget_show (sf_interface->progress_bar); sf_interface->progress_label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (sf_interface->progress_label), 0.0, 0.5); gtk_label_set_ellipsize (GTK_LABEL (sf_interface->progress_label), PANGO_ELLIPSIZE_MIDDLE); gimp_label_set_attributes (GTK_LABEL (sf_interface->progress_label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox2), sf_interface->progress_label, FALSE, FALSE, 0); gtk_widget_show (sf_interface->progress_label); gtk_widget_show (dialog); gtk_main (); return sf_status; }
static gboolean 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_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_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; }