static void gimp_rotate_tool_dialog (GimpTransformTool *tr_tool) { GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool); GtkWidget *table; GtkWidget *button; GtkWidget *scale; GtkObject *adj; table = gtk_table_new (4, 2, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (tr_tool->dialog))), table, FALSE, FALSE, 0); gtk_widget_show (table); button = gimp_spin_button_new ((GtkObject **) &rotate->angle_adj, 0, -180, 180, 0.1, 15, 0, 2, 2); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (button), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Angle:"), 0.0, 0.5, button, 1, TRUE); rotate->angle_spin_button = button; g_signal_connect (rotate->angle_adj, "value-changed", G_CALLBACK (rotate_angle_changed), tr_tool); scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, rotate->angle_adj); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show (scale); button = gimp_spin_button_new (&adj, 0, -1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Center _X:"), 0.0, 0.5, button, 1, TRUE); rotate->sizeentry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (rotate->sizeentry), GTK_SPIN_BUTTON (button), NULL); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (rotate->sizeentry), 2); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Center _Y:"), 0.0, 0.5, rotate->sizeentry, 1, TRUE); g_signal_connect (rotate->sizeentry, "value-changed", G_CALLBACK (rotate_center_changed), tr_tool); }
static GtkAdjustment * create_levels_scale (gdouble value, const gchar *left, const gchar *right, GtkWidget *table, gint col) { GtkWidget *label; GtkWidget *slider; GtkWidget *spinbutton; GtkAdjustment *adj; label = gtk_label_new (left); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, col, col + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new ((GtkObject **) &adj, value, -100.0, 100.0, 1.0, 10.0, 0.0, 1.0, 0); slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj); gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE); gtk_widget_set_size_request (slider, 100, -1); gtk_table_attach_defaults (GTK_TABLE (table), slider, 1, 2, col, col + 1); gtk_widget_show (slider); label = gtk_label_new (right); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 2, 3, col, col + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), spinbutton, 3, 4, col, col + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (spinbutton); return adj; }
static GtkObject * gimp_scale_entry_new_internal (gboolean color_scale, GtkTable *table, gint column, gint row, const gchar *text, gint scale_width, gint spinbutton_width, gdouble value, gdouble lower, gdouble upper, gdouble step_increment, gdouble page_increment, guint digits, gboolean constrain, gdouble unconstrained_lower, gdouble unconstrained_upper, const gchar *tooltip, const gchar *help_id) { GtkWidget *label; GtkWidget *scale; GtkWidget *spinbutton; GtkObject *adjustment; GtkObject *return_adj; label = gtk_label_new_with_mnemonic (text); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, column, column + 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (label); if (! constrain && unconstrained_lower <= lower && unconstrained_upper >= upper) { GtkObject *constrained_adj; constrained_adj = gtk_adjustment_new (value, lower, upper, step_increment, page_increment, 0.0); spinbutton = gimp_spin_button_new (&adjustment, value, unconstrained_lower, unconstrained_upper, step_increment, page_increment, 0.0, 1.0, digits); g_signal_connect (G_OBJECT (constrained_adj), "value-changed", G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback), adjustment); g_signal_connect (G_OBJECT (adjustment), "value-changed", G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback), constrained_adj); return_adj = adjustment; adjustment = constrained_adj; } else { spinbutton = gimp_spin_button_new (&adjustment, value, lower, upper, step_increment, page_increment, 0.0, 1.0, digits); return_adj = adjustment; } gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); if (spinbutton_width > 0) { if (spinbutton_width < 17) gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width); else gtk_widget_set_size_request (spinbutton, spinbutton_width, -1); } if (color_scale) { scale = gimp_color_scale_new (GTK_ORIENTATION_HORIZONTAL, GIMP_COLOR_SELECTOR_VALUE); gtk_range_set_adjustment (GTK_RANGE (scale), GTK_ADJUSTMENT (adjustment)); } else { scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment)); } if (scale_width > 0) gtk_widget_set_size_request (scale, scale_width, -1); gtk_scale_set_digits (GTK_SCALE (scale), digits); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gtk_table_attach (GTK_TABLE (table), scale, column + 1, column + 2, row, row + 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); gtk_widget_show (scale); gtk_table_attach (GTK_TABLE (table), spinbutton, column + 2, column + 3, row, row + 1, GTK_FILL | GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (spinbutton); if (tooltip || help_id) { gimp_help_set_help_data (label, tooltip, help_id); gimp_help_set_help_data (scale, tooltip, help_id); gimp_help_set_help_data (spinbutton, tooltip, help_id); } g_object_set_data (G_OBJECT (return_adj), "label", label); g_object_set_data (G_OBJECT (return_adj), "scale", scale); g_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton); return return_adj; }
/** * gimp_display_shell_scale_dialog: * @shell: the #GimpDisplayShell * * Constructs and displays a dialog allowing the user to enter a * custom display scale. **/ void gimp_display_shell_scale_dialog (GimpDisplayShell *shell) { ScaleDialogData *data; GimpImage *image; GtkWidget *toplevel; GtkWidget *hbox; GtkWidget *grid; GtkWidget *spin; GtkWidget *label; gint num, denom, row; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); if (shell->scale_dialog) { gtk_window_present (GTK_WINDOW (shell->scale_dialog)); return; } if (SCALE_EQUALS (shell->other_scale, 0.0)) { /* other_scale not yet initialized */ shell->other_scale = gimp_zoom_model_get_factor (shell->zoom); } image = gimp_display_get_image (shell->display); data = g_slice_new (ScaleDialogData); data->shell = shell; data->model = g_object_new (GIMP_TYPE_ZOOM_MODEL, "value", fabs (shell->other_scale), NULL); shell->scale_dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), gimp_get_user_context (shell->display->gimp), _("Zoom Ratio"), "display_scale", "zoom-original", _("Select Zoom Ratio"), GTK_WIDGET (shell), gimp_standard_help_func, GIMP_HELP_VIEW_ZOOM_OTHER, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_OK"), GTK_RESPONSE_OK, NULL); gimp_dialog_set_alternative_button_order (GTK_DIALOG (shell->scale_dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_weak_ref (G_OBJECT (shell->scale_dialog), (GWeakNotify) gimp_display_shell_scale_dialog_free, data); g_object_weak_ref (G_OBJECT (shell->scale_dialog), (GWeakNotify) g_object_unref, data->model); g_object_add_weak_pointer (G_OBJECT (shell->scale_dialog), (gpointer) &shell->scale_dialog); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (shell)); gtk_window_set_transient_for (GTK_WINDOW (shell->scale_dialog), GTK_WINDOW (toplevel)); gtk_window_set_destroy_with_parent (GTK_WINDOW (shell->scale_dialog), TRUE); g_signal_connect (shell->scale_dialog, "response", G_CALLBACK (gimp_display_shell_scale_dialog_response), data); grid = gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (grid), 12); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell->scale_dialog))), grid, TRUE, TRUE, 0); gtk_widget_show (grid); row = 0; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gimp_grid_attach_aligned (GTK_GRID (grid), 0, row++, _("Zoom ratio:"), 0.0, 0.5, hbox, 1); gimp_zoom_model_get_fraction (data->model, &num, &denom); data->num_adj = gtk_adjustment_new (num, 1, 256, 1, 8, 0); spin = gimp_spin_button_new (data->num_adj, 1.0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin), TRUE); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); label = gtk_label_new (":"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); data->denom_adj = gtk_adjustment_new (denom, 1, 256, 1, 8, 0); spin = gimp_spin_button_new (data->denom_adj, 1.0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin), TRUE); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gimp_grid_attach_aligned (GTK_GRID (grid), 0, row++, _("Zoom:"), 0.0, 0.5, hbox, 1); data->scale_adj = gtk_adjustment_new (fabs (shell->other_scale) * 100, 100.0 / 256.0, 25600.0, 10, 50, 0); spin = gimp_spin_button_new (data->scale_adj, 1.0, 2); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin), TRUE); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); label = gtk_label_new ("%"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_signal_connect (data->scale_adj, "value-changed", G_CALLBACK (update_zoom_values), data); g_signal_connect (data->num_adj, "value-changed", G_CALLBACK (update_zoom_values), data); g_signal_connect (data->denom_adj, "value-changed", G_CALLBACK (update_zoom_values), data); gtk_widget_show (shell->scale_dialog); }
/* * snap_dialog * * Bring up the GTK dialog for setting snapshot * parameters. */ static gboolean snap_dialog (void) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adj; GSList *radio_group = NULL; gint radio_pressed[2]; gint decorations; gboolean run; /* Set defaults */ radio_pressed[0] = (winsnapvals.root == FALSE); radio_pressed[1] = (winsnapvals.root == TRUE); decorations = winsnapvals.decor; /* Init GTK */ gimp_ui_init (PLUG_IN_BINARY, FALSE); /* Main Dialog */ dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Grab"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); winsnapintf.single_button = gtk_radio_button_new_with_label (radio_group, _("Grab a single window")); gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0); g_signal_connect (winsnapintf.single_button, "toggled", G_CALLBACK (snap_toggle_update), &radio_pressed[0]); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button), radio_pressed[0]); gtk_widget_show (winsnapintf.single_button); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button)); winsnapintf.root_button = gtk_radio_button_new_with_label (radio_group, _("Grab the whole screen")); gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0); g_signal_connect (winsnapintf.root_button, "toggled", G_CALLBACK (snap_toggle_update), &radio_pressed[1]); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button), radio_pressed[1]); gtk_widget_show (winsnapintf.root_button); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button)); /* with delay */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("after")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); winsnapintf.delay_spinner = gimp_spin_button_new (&adj, winsnapvals.delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), winsnapintf.delay_spinner, FALSE, FALSE, 0); gtk_widget_show (winsnapintf.delay_spinner); label = gtk_label_new (_("Seconds delay")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); #ifdef CAN_SET_DECOR /* With decorations */ winsnapintf.decor_button = gtk_check_button_new_with_label (_("Include decorations")); g_signal_connect (winsnapintf.decor_button, "toggled", G_CALLBACK (snap_toggle_update), &decorations); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button), decorations); gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0); gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]); gtk_widget_show (winsnapintf.decor_button); #endif /* CAN_SET_DECOR */ gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { winsnapvals.root = radio_pressed[1]; winsnapvals.decor = decorations; winsnapvals.delay = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner)); } gtk_widget_destroy (dialog); return run; }
static GtkWidget * print_size_frame (PrintData *data, GtkSizeGroup *label_group, GtkSizeGroup *entry_group) { GtkWidget *entry; GtkWidget *height; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *chain; GtkWidget *frame; GtkWidget *label; GtkObject *adj; gdouble image_width; gdouble image_height; image_width = (info.image_width * gimp_unit_get_factor (data->unit) / data->xres); image_height = (info.image_height * gimp_unit_get_factor (data->unit) / data->yres); frame = gimp_frame_new (_("Size")); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* the print size entry */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); entry = gimp_size_entry_new (1, data->unit, "%p", FALSE, FALSE, FALSE, SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); info.size_entry = GIMP_SIZE_ENTRY (entry); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); height = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (height), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), height, 1, 2, 0, 1); gtk_widget_show (height); gtk_size_group_add_widget (entry_group, height); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Width:"), 0, 0, 0.0); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Height:"), 1, 0, 0.0); gtk_size_group_add_widget (label_group, label); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, data->xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, data->yres, FALSE); gimp_size_entry_set_value (GIMP_SIZE_ENTRY (entry), 0, image_width); gimp_size_entry_set_value (GIMP_SIZE_ENTRY (entry), 1, image_height); /* the resolution entry */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); entry = gimp_size_entry_new (1, data->image_unit, _("pixels/%a"), FALSE, FALSE, FALSE, SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); info.resolution_entry = GIMP_SIZE_ENTRY (entry); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); height = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (height), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), height, 1, 2, 0, 1); gtk_widget_show (height); gtk_size_group_add_widget (entry_group, height); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X resolution:"), 0, 0, 0.0); gtk_size_group_add_widget (label_group, label); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y resolution:"), 1, 0, 0.0); gtk_size_group_add_widget (label_group, label); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (entry), 0, GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (entry), 1, GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, data->xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, data->yres); chain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain), TRUE); gtk_table_attach (GTK_TABLE (entry), chain, 2, 3, 0, 2, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (chain); info.chain = GIMP_CHAIN_BUTTON (chain); g_signal_connect (info.resolution_entry, "value-changed", G_CALLBACK (print_size_info_resolution_changed), NULL); g_signal_connect (info.size_entry, "unit-changed", G_CALLBACK (print_size_info_unit_changed), NULL); return frame; }
static void gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool) { GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool); GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool); GimpLevelsConfig *config = tool->config; GtkListStore *store; GtkSizeGroup *label_group; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *vbox3; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *label; GtkWidget *menu; GtkWidget *frame; GtkWidget *hbbox; GtkWidget *button; GtkWidget *spinbutton; GtkWidget *bar; GtkObject *data; gint border; g_signal_connect (image_map_tool->settings_box, "file-dialog-setup", G_CALLBACK (gimp_levels_tool_export_setup), image_map_tool); main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool); label_group = gimp_image_map_tool_dialog_get_label_group (image_map_tool); /* The option menu for selecting channels */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Cha_nnel:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_size_group_add_widget (label_group, label); store = gimp_enum_store_new_with_range (GIMP_TYPE_HISTOGRAM_CHANNEL, GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_ALPHA); menu = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store)); g_object_unref (store); g_signal_connect (menu, "changed", G_CALLBACK (levels_channel_callback), tool); gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (menu), "gimp-channel"); gtk_box_pack_start (GTK_BOX (hbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); tool->channel_menu = menu; gtk_label_set_mnemonic_widget (GTK_LABEL (label), menu); button = gtk_button_new_with_mnemonic (_("R_eset Channel")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_channel_reset_callback), tool); menu = gimp_prop_enum_stock_box_new (G_OBJECT (tool_options), "histogram-scale", "gimp-histogram", 0, 0); gtk_box_pack_end (GTK_BOX (hbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); /* Input levels frame */ frame = gimp_frame_new (_("Input Levels")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (frame), vbox2); gtk_widget_show (vbox2); tool->histogram_view = gimp_histogram_view_new (FALSE); gtk_box_pack_start (GTK_BOX (vbox2), tool->histogram_view, TRUE, TRUE, 0); gtk_widget_show (GTK_WIDGET (tool->histogram_view)); gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options), GIMP_HISTOGRAM_VIEW (tool->histogram_view)); g_object_get (tool->histogram_view, "border-width", &border, NULL); vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox3), border); gtk_box_pack_start (GTK_BOX (vbox2), vbox3, FALSE, FALSE, 0); gtk_widget_show (vbox3); tool->input_bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL); gtk_widget_set_size_request (tool->input_bar, -1, GRADIENT_HEIGHT / 2); gtk_box_pack_start (GTK_BOX (vbox3), tool->input_bar, FALSE, FALSE, 0); gtk_widget_show (tool->input_bar); bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL); gtk_widget_set_size_request (bar, -1, GRADIENT_HEIGHT / 2); gtk_box_pack_start (GTK_BOX (vbox3), bar, FALSE, FALSE, 0); gtk_widget_show (bar); tool->input_sliders = g_object_new (GIMP_TYPE_HANDLE_BAR, NULL); gtk_widget_set_size_request (tool->input_sliders, -1, CONTROL_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox3), tool->input_sliders, FALSE, FALSE, 0); gtk_widget_show (tool->input_sliders); g_signal_connect_swapped (tool->input_bar, "button-press-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->input_sliders)->button_press_event), tool->input_sliders); g_signal_connect_swapped (tool->input_bar, "button-release-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->input_sliders)->button_release_event), tool->input_sliders); g_signal_connect_swapped (tool->input_bar, "motion-notify-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->input_sliders)->motion_notify_event), tool->input_sliders); g_signal_connect_swapped (bar, "button-press-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->input_sliders)->button_press_event), tool->input_sliders); g_signal_connect_swapped (bar, "button-release-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->input_sliders)->button_release_event), tool->input_sliders); g_signal_connect_swapped (bar, "motion-notify-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->input_sliders)->motion_notify_event), tool->input_sliders); /* Horizontal box for input levels spinbuttons */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low input spin */ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); button = gimp_levels_tool_color_picker_new (tool, PICK_LOW_INPUT); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); gtk_widget_show (button); spinbutton = gimp_spin_button_new (&data, config->low_input[config->channel] * 255.0, 0, 255, 1, 10, 0, 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->low_input = GTK_ADJUSTMENT (data); g_signal_connect (tool->low_input, "value-changed", G_CALLBACK (levels_low_input_changed), tool); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (tool->input_sliders), 0, tool->low_input); /* input gamma spin */ spinbutton = gimp_spin_button_new (&data, config->gamma[config->channel], 0.1, 10, 0.01, 0.1, 0, 0.5, 2); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, FALSE, 0); gimp_help_set_help_data (spinbutton, _("Gamma"), NULL); gtk_widget_show (spinbutton); tool->gamma = GTK_ADJUSTMENT (data); g_signal_connect (tool->gamma, "value-changed", G_CALLBACK (levels_gamma_changed), tool); tool->gamma_linear = GTK_ADJUSTMENT (gtk_adjustment_new (127, 0, 255, 0.1, 1.0, 0.0)); g_signal_connect (tool->gamma_linear, "value-changed", G_CALLBACK (levels_linear_gamma_changed), tool); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (tool->input_sliders), 1, tool->gamma_linear); g_object_unref (tool->gamma_linear); /* high input spin */ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); button = gimp_levels_tool_color_picker_new (tool, PICK_HIGH_INPUT); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); gtk_widget_show (button); spinbutton = gimp_spin_button_new (&data, config->high_input[config->channel] * 255.0, 0, 255, 1, 10, 0, 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->high_input = GTK_ADJUSTMENT (data); g_signal_connect (tool->high_input, "value-changed", G_CALLBACK (levels_high_input_changed), tool); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (tool->input_sliders), 2, tool->high_input); /* Output levels frame */ frame = gimp_frame_new (_("Output Levels")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox2), border); gtk_container_add (GTK_CONTAINER (frame), vbox2); gtk_widget_show (vbox2); tool->output_bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL); gtk_widget_set_size_request (tool->output_bar, -1, GRADIENT_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox2), tool->output_bar, FALSE, FALSE, 0); gtk_widget_show (tool->output_bar); tool->output_sliders = g_object_new (GIMP_TYPE_HANDLE_BAR, NULL); gtk_widget_set_size_request (tool->output_sliders, -1, CONTROL_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox2), tool->output_sliders, FALSE, FALSE, 0); gtk_widget_show (tool->output_sliders); g_signal_connect_swapped (tool->output_bar, "button-press-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->output_sliders)->button_press_event), tool->output_sliders); g_signal_connect_swapped (tool->output_bar, "button-release-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->output_sliders)->button_release_event), tool->output_sliders); g_signal_connect_swapped (tool->output_bar, "motion-notify-event", G_CALLBACK (GTK_WIDGET_GET_CLASS (tool->output_sliders)->motion_notify_event), tool->output_sliders); /* Horizontal box for levels spin widgets */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low output spin */ spinbutton = gimp_spin_button_new (&data, config->low_output[config->channel] * 255.0, 0, 255, 1, 10, 0, 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->low_output = GTK_ADJUSTMENT (data); g_signal_connect (tool->low_output, "value-changed", G_CALLBACK (levels_low_output_changed), tool); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (tool->output_sliders), 0, tool->low_output); /* high output spin */ spinbutton = gimp_spin_button_new (&data, config->high_output[config->channel] * 255.0, 0, 255, 1, 10, 0, 0.5, 0); gtk_box_pack_end (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->high_output = GTK_ADJUSTMENT (data); g_signal_connect (tool->high_output, "value-changed", G_CALLBACK (levels_high_output_changed), tool); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (tool->output_sliders), 2, tool->high_output); /* all channels frame */ frame = gimp_frame_new (_("All Channels")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); hbbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0); gtk_widget_show (hbbox); button = gtk_button_new_with_mnemonic (_("_Auto")); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gimp_help_set_help_data (button, _("Adjust levels automatically"), NULL); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_stretch_callback), tool); button = gimp_levels_tool_color_picker_new (tool, PICK_LOW_INPUT | PICK_ALL_CHANNELS); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_levels_tool_color_picker_new (tool, PICK_GAMMA | PICK_ALL_CHANNELS); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_levels_tool_color_picker_new (tool, PICK_HIGH_INPUT | PICK_ALL_CHANNELS); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (image_map_tool->dialog, "unmap", G_CALLBACK (gimp_levels_tool_dialog_unmap), tool); button = gimp_stock_button_new (GIMP_STOCK_TOOL_CURVES, _("Edit these Settings as Curves")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_to_curves_callback), tool); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu), config->channel); }
static gboolean webpage_dialog (void) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *entry; GtkSizeGroup *sizegroup; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *combo; gint active; gint status; gboolean ret = FALSE; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Create from webpage"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Create"), 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)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); image = gtk_image_new_from_stock (GIMP_STOCK_WEB, GTK_ICON_SIZE_BUTTON); gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0); gtk_widget_show (image); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Enter location (URI):")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); entry = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); gtk_widget_set_size_request (entry, 400, -1); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); if (webpagevals.url) gtk_entry_set_text (GTK_ENTRY (entry), webpagevals.url); gtk_widget_show (entry); sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); /* Width */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Width (pixels):")); gtk_size_group_add_widget (sizegroup, label); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&adjustment, webpagevals.width, 1, 8192, 1, 10, 0, 1, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); /* Font size */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Font size:")); gtk_size_group_add_widget (sizegroup, label); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_int_combo_box_new (_("Huge"), 16, _("Large"), 14, C_("web-page", "Default"), 12, _("Small"), 10, _("Tiny"), 8, NULL); switch (webpagevals.font_size) { case 16: case 14: case 12: case 10: case 8: active = webpagevals.font_size; break; default: active = 12; } gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), active); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); gtk_widget_show (combo); g_object_unref (sizegroup); status = gimp_dialog_run (GIMP_DIALOG (dialog)); if (status == GTK_RESPONSE_OK) { g_free (webpagevals.url); webpagevals.url = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry))); webpagevals.width = (gint) gtk_adjustment_get_value (GTK_ADJUSTMENT (adjustment)); gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &webpagevals.font_size); ret = TRUE; } gtk_widget_destroy (dialog); return ret; }
GtkWidget * convert_dialog_new (GimpImage *image, GimpContext *context, GtkWidget *parent, GimpProgress *progress) { IndexedDialog *dialog; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *toggle; GtkWidget *palette_box; GtkWidget *combo; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); dialog = g_slice_new0 (IndexedDialog); dialog->image = image; dialog->progress = progress; dialog->dither_type = saved_dither_type; dialog->alpha_dither = saved_alpha_dither; dialog->remove_dups = saved_remove_dups; dialog->num_colors = saved_num_colors; dialog->palette_type = saved_palette_type; dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Indexed Color Conversion"), "gimp-image-convert-indexed", GIMP_STOCK_CONVERT_INDEXED, _("Convert Image to Indexed Colors"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_CONVERT_INDEXED, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("C_onvert"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GIMP_STOCK_CONVERT_INDEXED, GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) convert_dialog_free, dialog); g_signal_connect (dialog->dialog, "response", G_CALLBACK (convert_dialog_response), dialog); palette_box = convert_dialog_palette_box (dialog); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog->dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); /* palette */ frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_CONVERT_PALETTE_TYPE, GIMP_MAKE_PALETTE, (palette_box ? GIMP_CUSTOM_PALETTE : GIMP_MONO_PALETTE), gtk_label_new (_("Colormap")), G_CALLBACK (gimp_radio_button_update), &dialog->palette_type, &button); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), dialog->palette_type); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* max n_colors */ hbox = gtk_hbox_new (FALSE, 6); gimp_enum_radio_frame_add (GTK_FRAME (frame), hbox, GIMP_MAKE_PALETTE); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("_Maximum number of colors:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); if (dialog->num_colors == 256 && gimp_image_has_alpha (image)) dialog->num_colors = 255; spinbutton = gimp_spin_button_new (&adjustment, dialog->num_colors, 2, 256, 1, 8, 0, 1, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &dialog->num_colors); /* custom palette */ if (palette_box) { gimp_enum_radio_frame_add (GTK_FRAME (frame), palette_box, GIMP_CUSTOM_PALETTE); gtk_widget_show (palette_box); } vbox = gtk_bin_get_child (GTK_BIN (frame)); toggle = gtk_check_button_new_with_mnemonic (_("_Remove unused colors " "from colormap")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->remove_dups); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 3); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->remove_dups); g_object_set_data (G_OBJECT (button), "inverse_sensitive", toggle); gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (button)); /* dithering */ frame = gimp_frame_new (_("Dithering")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Color _dithering:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_enum_combo_box_new (GIMP_TYPE_CONVERT_DITHER_TYPE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dialog->dither_type, G_CALLBACK (gimp_int_combo_box_get_active), &dialog->dither_type); toggle = gtk_check_button_new_with_mnemonic (_("Enable dithering of _transparency")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->alpha_dither); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->alpha_dither); return dialog->dialog; }
static void gimp_resolution_entry_field_init (GimpResolutionEntry *gre, GimpResolutionEntryField *gref, GimpResolutionEntryField *corresponding, guint changed_signal, gdouble initial_val, GimpUnit initial_unit, gboolean size, gint spinbutton_width) { gint digits; g_return_if_fail (GIMP_IS_RESOLUTION_ENTRY (gre)); gref->gre = gre; gref->corresponding = corresponding; gref->changed_signal = gimp_resolution_entry_signals[changed_signal]; if (size) { gref->value = initial_val / gimp_unit_get_factor (initial_unit) * corresponding->value * gimp_unit_get_factor (gre->unit); gref->phy_size = initial_val / gimp_unit_get_factor (initial_unit); } else { gref->value = initial_val; } gref->min_value = GIMP_MIN_RESOLUTION; gref->max_value = GIMP_MAX_RESOLUTION; gref->adjustment = NULL; gref->stop_recursion = 0; gref->size = size; if (size) { gref->label = g_object_new (GTK_TYPE_LABEL, "xalign", 0.0, "yalign", 0.5, NULL); gimp_label_set_attributes (GTK_LABEL (gref->label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gimp_resolution_entry_format_label (gre, gref->label, gref->phy_size); } digits = size ? 0 : MIN (gimp_unit_get_digits (initial_unit), 5) + 1; gref->spinbutton = gimp_spin_button_new (&gref->adjustment, gref->value, gref->min_value, gref->max_value, 1.0, 10.0, 0.0, 1.0, digits); if (spinbutton_width > 0) { if (spinbutton_width < 17) gtk_entry_set_width_chars (GTK_ENTRY (gref->spinbutton), spinbutton_width); else gtk_widget_set_size_request (gref->spinbutton, spinbutton_width, -1); } }
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; }
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; }
/** * gimp_coordinates_new: * @unit: The initial unit of the #GimpUnitMenu. * @unit_format: A printf-like unit-format string as is used with * gimp_unit_menu_new(). * @menu_show_pixels: %TRUE if the #GimpUnitMenu should contain an item * for GIMP_UNIT_PIXEL. * @menu_show_percent: %TRUE if the #GimpUnitMenu should contain an item * for GIMP_UNIT_PERCENT. * @spinbutton_width: The horizontal size of the #GimpSizeEntry's * #GtkSpinButton's. * @update_policy: The update policy for the #GimpSizeEntry. * @chainbutton_active: %TRUE if the attached #GimpChainButton should be * active. * @chain_constrains_ratio: %TRUE if the chainbutton should constrain the * fields' aspect ratio. If %FALSE, the values will * be constrained. * @xlabel: The label for the X coordinate. * @x: The initial value of the X coordinate. * @xres: The horizontal resolution in DPI. * @lower_boundary_x: The lower boundary of the X coordinate. * @upper_boundary_x: The upper boundary of the X coordinate. * @xsize_0: The X value which will be treated as 0%. * @xsize_100: The X value which will be treated as 100%. * @ylabel: The label for the Y coordinate. * @y: The initial value of the Y coordinate. * @yres: The vertical resolution in DPI. * @lower_boundary_y: The lower boundary of the Y coordinate. * @upper_boundary_y: The upper boundary of the Y coordinate. * @ysize_0: The Y value which will be treated as 0%. * @ysize_100: The Y value which will be treated as 100%. * * Convenience function that creates a #GimpSizeEntry with two fields for x/y * coordinates/sizes with a #GimpChainButton attached to constrain either the * two fields' values or the ratio between them. * * Returns: The new #GimpSizeEntry. **/ GtkWidget * gimp_coordinates_new (GimpUnit unit, const gchar *unit_format, gboolean menu_show_pixels, gboolean menu_show_percent, gint spinbutton_width, GimpSizeEntryUpdatePolicy update_policy, gboolean chainbutton_active, gboolean chain_constrains_ratio, const gchar *xlabel, gdouble x, gdouble xres, gdouble lower_boundary_x, gdouble upper_boundary_x, gdouble xsize_0, /* % */ gdouble xsize_100, /* % */ const gchar *ylabel, gdouble y, gdouble yres, gdouble lower_boundary_y, gdouble upper_boundary_y, gdouble ysize_0, /* % */ gdouble ysize_100 /* % */) { GimpCoordinatesData *data; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *sizeentry; GtkWidget *chainbutton; spinbutton = gimp_spin_button_new (&adjustment, 1, 0, 1, 1, 10, 0, 1, 2); if (spinbutton_width > 0) { if (spinbutton_width < 17) gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width); else gtk_widget_set_size_request (spinbutton, spinbutton_width, -1); } sizeentry = gimp_size_entry_new (1, unit, unit_format, menu_show_pixels, menu_show_percent, FALSE, spinbutton_width, update_policy); gtk_table_set_col_spacing (GTK_TABLE (sizeentry), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (sizeentry), 2, 4); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (sizeentry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (sizeentry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (sizeentry), (update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION) || (menu_show_pixels == FALSE) ? GIMP_UNIT_INCH : GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 1, yres, TRUE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 0, lower_boundary_x, upper_boundary_x); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 1, lower_boundary_y, upper_boundary_y); if (menu_show_percent) { gimp_size_entry_set_size (GIMP_SIZE_ENTRY (sizeentry), 0, xsize_0, xsize_100); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (sizeentry), 1, ysize_0, ysize_100); } gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 0, x); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 1, y); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (sizeentry), xlabel, 0, 0, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (sizeentry), ylabel, 1, 0, 0.0); chainbutton = gimp_chain_button_new (GIMP_CHAIN_RIGHT); if (chainbutton_active) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chainbutton), TRUE); gtk_table_attach (GTK_TABLE (sizeentry), chainbutton, 2, 3, 0, 2, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (chainbutton); data = g_slice_new (GimpCoordinatesData); data->chainbutton = GIMP_CHAIN_BUTTON (chainbutton); data->chain_constrains_ratio = chain_constrains_ratio; data->orig_x = x; data->orig_y = y; data->last_x = x; data->last_y = y; g_object_set_data_full (G_OBJECT (sizeentry), "coordinates-data", data, (GDestroyNotify) gimp_coordinates_data_free); g_signal_connect (sizeentry, "value-changed", G_CALLBACK (gimp_coordinates_callback), data); g_object_set_data (G_OBJECT (sizeentry), "chainbutton", chainbutton); g_signal_connect (chainbutton, "toggled", G_CALLBACK (gimp_coordinates_chainbutton_toggled), sizeentry); return sizeentry; }
/** * gimp_random_seed_new: * @seed: A pointer to the variable which stores the random seed. * @random_seed: A pointer to a boolean indicating whether seed should be * initialised randomly or not. * * Creates a widget that allows the user to control how the random number * generator is initialized. * * Returns: A #GtkHBox containing a #GtkSpinButton for the seed and * a #GtkButton for setting a random seed. **/ GtkWidget * gimp_random_seed_new (guint *seed, gboolean *random_seed) { GtkWidget *hbox; GtkWidget *toggle; GtkWidget *spinbutton; GtkObject *adj; GtkWidget *button; g_return_val_if_fail (seed != NULL, NULL); g_return_val_if_fail (random_seed != NULL, NULL); hbox = gtk_hbox_new (FALSE, 4); /* If we're being asked to generate a random seed, generate one. */ if (*random_seed) *seed = g_random_int (); spinbutton = gimp_spin_button_new (&adj, *seed, 0, (guint32) -1 , 1, 10, 0, 1, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_uint_adjustment_update), seed); gimp_help_set_help_data (spinbutton, _("Use this value for random number generator " "seed - this allows you to repeat a " "given \"random\" operation"), NULL); button = gtk_button_new_with_mnemonic (_("_New Seed")); gtk_misc_set_padding (GTK_MISC (gtk_bin_get_child (GTK_BIN (button))), 2, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); /* Send spinbutton as data so that we can change the value in * gimp_random_seed_update() */ g_signal_connect (button, "clicked", G_CALLBACK (gimp_random_seed_update), spinbutton); gimp_help_set_help_data (button, _("Seed random number generator with a generated " "random number"), NULL); toggle = gtk_check_button_new_with_mnemonic (_("_Randomize")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), *random_seed); gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), random_seed); /* Need to create a new seed when the "Randomize" toggle is activated */ g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_random_seed_update), spinbutton); g_object_set_data (G_OBJECT (hbox), "spinbutton", spinbutton); g_object_set_data (G_OBJECT (hbox), "button", button); g_object_set_data (G_OBJECT (hbox), "toggle", toggle); g_object_bind_property (toggle, "active", spinbutton, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_object_bind_property (toggle, "active", button, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); return hbox; }
static GtkWidget * gimp_align_tool_controls (GimpAlignTool *align_tool) { GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *label; GtkWidget *button; GtkWidget *spinbutton; GtkWidget *combo; gint n = 0; main_vbox = gtk_vbox_new (FALSE, 12); frame = gimp_frame_new (_("Align")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_frame_new (_("Relative to:")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); combo = gimp_enum_combo_box_new (GIMP_TYPE_ALIGN_REFERENCE); gtk_container_add (GTK_CONTAINER (frame), combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), GIMP_ALIGN_REFERENCE_FIRST, G_CALLBACK (gimp_int_combo_box_get_active), &align_tool->align_reference_type); gtk_widget_show (combo); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = button_with_stock (GIMP_ALIGN_LEFT, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Align left edge of target"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ALIGN_HCENTER, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Align center of target"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ALIGN_RIGHT, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Align right edge of target"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = button_with_stock (GIMP_ALIGN_TOP, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Align top edge of target"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ALIGN_VCENTER, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Align middle of target"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ALIGN_BOTTOM, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Align bottom of target"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); frame = gimp_frame_new (_("Distribute")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = button_with_stock (GIMP_ARRANGE_LEFT, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Distribute left edges of targets"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ARRANGE_HCENTER, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Distribute horizontal centers of targets"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ARRANGE_RIGHT, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Distribute right edges of targets"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = button_with_stock (GIMP_ARRANGE_TOP, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Distribute top edges of targets"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ARRANGE_VCENTER, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Distribute vertical centers of targets"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = button_with_stock (GIMP_ARRANGE_BOTTOM, align_tool); align_tool->button[n++] = button; gimp_help_set_help_data (button, _("Distribute bottoms of targets"), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Offset:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&align_tool->horz_offset_adjustment, 0, -100000., 100000., 1., 20., 20., 1., 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); g_signal_connect (align_tool->horz_offset_adjustment, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &align_tool->horz_offset); gtk_widget_show (spinbutton); return main_vbox; }
gint gap_resi_dialog (gint32 image_id, GapRangeOpsAsiz asiz_mode, char *title_text, long *size_x, long *size_y, long *offs_x, long *offs_y) { gint l_run; GapResizePrivateType *res_private; GtkWidget *hbbox; GtkWidget *button; GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *table; GtkWidget *table2; GtkWidget *table3; GtkWidget *label; GtkWidget *frame; GtkWidget *spinbutton; GtkWidget *abox; gdouble l_max_image_width; gdouble l_max_image_height; gdouble l_max_ratio_x; gdouble l_max_ratio_y; abox = NULL; frame = NULL; /* Initialize the GapResizePrivateType structure */ res_private = (GapResizePrivateType *) g_malloc (sizeof (GapResizePrivateType)); res_private->image_id = image_id; res_private->run = FALSE; res_private->in_call = FALSE; res_private->asiz_mode = asiz_mode; /* get info about the image (size is common to all frames) */ res_private->orig_width = gimp_image_width(image_id); res_private->orig_height = gimp_image_height(image_id); res_private->width = res_private->orig_width; res_private->height = res_private->orig_height; res_private->offset_x = 0; res_private->offset_y = 0; res_private->ratio_x = 1.0; res_private->ratio_y = 1.0; l_max_image_width = GIMP_MAX_IMAGE_SIZE; l_max_image_height = GIMP_MAX_IMAGE_SIZE; l_max_ratio_x = (gdouble) GIMP_MAX_IMAGE_SIZE / (double) res_private->width; l_max_ratio_y = (gdouble) GIMP_MAX_IMAGE_SIZE / (double) res_private->height; /* for CROP mode only: set sizelimit to original width/height */ if(res_private->asiz_mode == GAP_ASIZ_CROP) { l_max_image_width = res_private->orig_width; l_max_image_height = res_private->orig_height; l_max_ratio_x = 1.0; l_max_ratio_y = 1.0; } res_private->offset_area = NULL; gimp_ui_init ("gap_res_dialog", FALSE); /* the dialog */ res_private->shell = gtk_dialog_new (); res_private->dlg = res_private->shell; gtk_window_set_title (GTK_WINDOW (res_private->shell), title_text); gtk_window_set_position (GTK_WINDOW (res_private->shell), GTK_WIN_POS_MOUSE); g_signal_connect (G_OBJECT (res_private->shell), "destroy", G_CALLBACK (p_res_cancel_callback), NULL); switch(res_private->asiz_mode) { case GAP_ASIZ_SCALE: frame = gimp_frame_new (_("Scale Frames")); break; case GAP_ASIZ_RESIZE: frame = gimp_frame_new (_("Resize Frames")); break; case GAP_ASIZ_CROP: frame = gimp_frame_new (_("Crop Frames")); break; } /* the main vbox */ main_vbox = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 4); /* gtk_container_add (GTK_CONTAINER (GTK_DIALOG (res_private->shell)->vbox), main_vbox); */ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (res_private->shell)->vbox), main_vbox, TRUE, TRUE, 0); /* button hbox */ gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (res_private->shell)->action_area), 2); gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (res_private->shell)->action_area), FALSE); hbbox = gtk_hbutton_box_new (); gtk_box_set_spacing (GTK_BOX (hbbox), 4); gtk_box_pack_end (GTK_BOX (GTK_DIALOG (res_private->shell)->action_area), hbbox, FALSE, FALSE, 0); gtk_widget_show (hbbox); /* the pixel dimensions frame */ gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); gtk_container_add (GTK_CONTAINER (frame), vbox); table = gtk_table_new (6, 2, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 4); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 4); gtk_table_set_row_spacing (GTK_TABLE (table), 3, 4); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); /* the original width & height labels */ label = gtk_label_new (_("Current 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 (_("Current 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); /* the original width & height Values labels */ res_private->orig_width_label = gtk_label_new (""); gtk_misc_set_alignment (GTK_MISC (res_private->orig_width_label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), res_private->orig_width_label, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res_private->orig_width_label); res_private->orig_height_label = gtk_label_new (""); gtk_misc_set_alignment (GTK_MISC (res_private->orig_height_label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), res_private->orig_height_label, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res_private->orig_height_label); /* the new size labels */ label = gtk_label_new (_("New width:")); 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); label = gtk_label_new (_("New height:")); 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 spinbutton entry new_width */ spinbutton = gimp_spin_button_new (&res_private->width_adj, res_private->orig_width, GIMP_MIN_IMAGE_SIZE, l_max_image_width, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH); gtk_widget_show (spinbutton); gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); g_signal_connect (res_private->width_adj, "value_changed", G_CALLBACK (p_size_callback), res_private); /* the spinbutton entry new_height */ spinbutton = gimp_spin_button_new (&res_private->height_adj, res_private->orig_height, GIMP_MIN_IMAGE_SIZE, l_max_image_height, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH); gtk_widget_show (spinbutton); gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); g_signal_connect (res_private->height_adj, "value_changed", G_CALLBACK (p_size_callback), res_private); /* initialize the original width & height labels */ p_orig_labels_update(NULL, res_private); /* the scale ratio labels */ label = gtk_label_new (_("X ratio:")); 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); label = gtk_label_new (_("Y ratio:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* a (2nd) table for the spinbuttons and the chainbutton */ abox = gtk_alignment_new (0.0, 0.5, 0.0, 1.0); 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, 2); gtk_container_add (GTK_CONTAINER (abox), table2); gtk_table_attach (GTK_TABLE (table), abox, 1, 2, 4, 6, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (abox); /* the spinbutton entry X-scale ratio */ spinbutton = gimp_spin_button_new (&res_private->ratio_x_adj, res_private->ratio_x, (double) GIMP_MIN_IMAGE_SIZE / (double) res_private->width, (double) l_max_ratio_x, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (res_private->ratio_x_adj, "value_changed", G_CALLBACK (p_ratio_callback), res_private); /* the spinbutton entry Y-scale ratio */ spinbutton = gimp_spin_button_new (&res_private->ratio_y_adj, res_private->ratio_y, (double) GIMP_MIN_IMAGE_SIZE / (double) res_private->height, (double) l_max_ratio_y, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (res_private->ratio_y_adj, "value_changed", G_CALLBACK (p_ratio_callback), res_private); /* the constrain ratio chainbutton */ res_private->constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (res_private->constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), res_private->constrain, 1, 2, 0, 2); gtk_widget_show (res_private->constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (res_private->constrain)->button, _("Constrain aspect ratio"), NULL); /* the state of the contrain ratio chainbutton is checked in other callbacks (where needed) * there is no need for the chainbutton to have its own callback procedure */ gtk_widget_show (table2); gtk_widget_show (table); gtk_widget_show (vbox); /* code for GAP_ASIZ_RESIZE GAP_ASIZ_CROP using offsets, GAP_ASIZ_SCALE does not */ if(res_private->asiz_mode != GAP_ASIZ_SCALE) { /* the offset frame */ frame = gimp_frame_new (_("Offset")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (vbox), 2); gtk_container_add (GTK_CONTAINER (frame), vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); /* a (3rd) table for the offset spinbuttons */ table3 = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table3), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table3), 0, 2); /* gtk_container_add (GTK_CONTAINER (abox), table3); */ /* the x/y offest labels */ label = gtk_label_new (_("X:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table3), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Y:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table3), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the spinbutton entry offset_x */ spinbutton = gimp_spin_button_new (&res_private->offset_x_adj, 0, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH); gtk_table_attach (GTK_TABLE (table3), spinbutton, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (spinbutton); g_signal_connect (res_private->offset_x_adj, "value_changed", G_CALLBACK (p_offset_update), res_private); /* the spinbutton entry offset_y */ spinbutton = gimp_spin_button_new (&res_private->offset_y_adj, 0, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), SB_WIDTH); gtk_table_attach (GTK_TABLE (table3), spinbutton, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (spinbutton); g_signal_connect (res_private->offset_y_adj, "value_changed", G_CALLBACK (p_offset_update), res_private); /* the center offsetX button */ button = gtk_button_new_with_label (_("Center Horizontal")); gtk_widget_show (button); gtk_table_attach (GTK_TABLE (table3), button, 2, 3, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (p_offset_x_center_clicked), res_private); /* the center offsetY button */ button = gtk_button_new_with_label (_("Center Vertical")); gtk_widget_show (button); gtk_table_attach (GTK_TABLE (table3), button, 2, 3, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (p_offset_y_center_clicked), res_private); gtk_container_add (GTK_CONTAINER (abox), table3); gtk_widget_show (table3); gtk_widget_show (abox); /* frame to hold GimpOffsetArea */ abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); frame = gimp_frame_new (NULL); gtk_container_add (GTK_CONTAINER (abox), frame); /* the GimpOffsetArea widget */ res_private->offset_area = gimp_offset_area_new (res_private->orig_width , res_private->orig_height); gtk_container_add (GTK_CONTAINER (frame), res_private->offset_area); gtk_widget_show (res_private->offset_area); g_signal_connect (res_private->offset_area, "offsets_changed", G_CALLBACK (p_offset_area_offsets_changed), res_private); gtk_widget_show (frame); gtk_widget_show (abox); gtk_widget_show (vbox); } /* Action area */ if (gimp_show_help_button ()) { button = gtk_button_new_from_stock ( GTK_STOCK_HELP); gtk_box_pack_end (GTK_BOX (hbbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (GTK_OBJECT (button), "clicked", G_CALLBACK (p_res_help_callback), res_private); } button = gtk_button_new_from_stock ( GIMP_STOCK_RESET); gtk_box_pack_start (GTK_BOX (hbbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (GTK_OBJECT (button), "clicked", G_CALLBACK (p_res_reset_callback), res_private); button = gtk_button_new_from_stock ( GTK_STOCK_CANCEL); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (hbbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (p_res_cancel_callback), NULL); button = gtk_button_new_from_stock ( GTK_STOCK_OK); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (hbbox), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); g_signal_connect (GTK_OBJECT (button), "clicked", G_CALLBACK (p_res_ok_callback), res_private); gtk_widget_show (main_vbox); gtk_widget_show (res_private->shell); gtk_main (); gdk_flush (); *size_x = res_private->width; *size_y = res_private->height; *offs_x = res_private->offset_x; *offs_y = res_private->offset_y; if(res_private->asiz_mode == GAP_ASIZ_CROP) { /* the widgets deliver negative offsets when new size is smaller * than original (as needed for gimp_image_resize calls) * but gimp_image_crop needs positive offets * therefore the sign is switched just for CROP operations */ *offs_x = - res_private->offset_x; *offs_y = - res_private->offset_y; } l_run = res_private->run; g_free(res_private); return (l_run); } /* end gap_resi_dialog */
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 void gimp_levels_tool_dialog (GimpImageMapTool *image_map_tool) { GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool); GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool); GtkListStore *store; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *vbox3; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *label; GtkWidget *menu; GtkWidget *frame; GtkWidget *hbbox; GtkWidget *button; GtkWidget *spinbutton; GtkWidget *bar; GtkObject *data; gint border; vbox = image_map_tool->main_vbox; /* The option menu for selecting channels */ 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 (_("Cha_nnel:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); store = gimp_enum_store_new_with_range (GIMP_TYPE_HISTOGRAM_CHANNEL, GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_ALPHA); menu = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store)); g_object_unref (store); g_signal_connect (menu, "changed", G_CALLBACK (levels_channel_callback), tool); gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (menu), "gimp-channel"); gtk_box_pack_start (GTK_BOX (hbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); tool->channel_menu = menu; gtk_label_set_mnemonic_widget (GTK_LABEL (label), menu); button = gtk_button_new_with_mnemonic (_("R_eset Channel")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_channel_reset_callback), tool); menu = gimp_prop_enum_stock_box_new (G_OBJECT (tool_options), "histogram-scale", "gimp-histogram", 0, 0); gtk_box_pack_end (GTK_BOX (hbox), menu, FALSE, FALSE, 0); gtk_widget_show (menu); /* Input levels frame */ frame = gimp_frame_new (_("Input Levels")); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox2 = gtk_vbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (frame), vbox2); gtk_widget_show (vbox2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox2), frame, TRUE, TRUE, 0); gtk_widget_show (frame); tool->hist_view = gimp_histogram_view_new (FALSE); gtk_container_add (GTK_CONTAINER (frame), tool->hist_view); gtk_widget_show (GTK_WIDGET (tool->hist_view)); gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options), GIMP_HISTOGRAM_VIEW (tool->hist_view)); g_object_get (tool->hist_view, "border-width", &border, NULL); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_widget_show (frame); tool->input_area = gtk_event_box_new (); gtk_widget_set_size_request (tool->input_area, -1, GRADIENT_HEIGHT + CONTROL_HEIGHT); gtk_widget_add_events (tool->input_area, LEVELS_EVENT_MASK); gtk_container_add (GTK_CONTAINER (frame), tool->input_area); gtk_widget_show (tool->input_area); g_signal_connect (tool->input_area, "event", G_CALLBACK (levels_input_area_event), tool); g_signal_connect_after (tool->input_area, "expose-event", G_CALLBACK (levels_input_area_expose), tool); vbox3 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (tool->input_area), vbox3); gtk_widget_show (vbox3); tool->input_bar = g_object_new (GIMP_TYPE_COLOR_BAR, "xpad", border, "ypad", 0, NULL); gtk_widget_set_size_request (tool->input_bar, -1, GRADIENT_HEIGHT / 2); gtk_box_pack_start (GTK_BOX (vbox3), tool->input_bar, FALSE, FALSE, 0); gtk_widget_show (tool->input_bar); bar = g_object_new (GIMP_TYPE_COLOR_BAR, "xpad", border, "ypad", 0, NULL); gtk_widget_set_size_request (bar, -1, GRADIENT_HEIGHT / 2); gtk_box_pack_start (GTK_BOX (vbox3), bar, FALSE, FALSE, 0); gtk_widget_show (bar); /* Horizontal box for input levels spinbuttons */ hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low input spin */ hbox2 = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); button = gimp_levels_tool_color_picker_new (tool, LOW_INPUT); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); gtk_widget_show (button); spinbutton = gimp_spin_button_new (&data, 0, 0, 255, 1, 10, 10, 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->low_input = GTK_ADJUSTMENT (data); g_signal_connect (tool->low_input, "value-changed", G_CALLBACK (levels_low_input_adjustment_update), tool); /* input gamma spin */ spinbutton = gimp_spin_button_new (&data, 1, 0.1, 10, 0.01, 0.1, 1, 0.5, 2); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, FALSE, 0); gimp_help_set_help_data (spinbutton, _("Gamma"), NULL); gtk_widget_show (spinbutton); tool->gamma = GTK_ADJUSTMENT (data); g_signal_connect (tool->gamma, "value-changed", G_CALLBACK (levels_gamma_adjustment_update), tool); /* high input spin */ hbox2 = gtk_hbox_new (FALSE, 2); gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); button = gimp_levels_tool_color_picker_new (tool, HIGH_INPUT); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); gtk_widget_show (button); spinbutton = gimp_spin_button_new (&data, 255, 0, 255, 1, 10, 10, 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->high_input = GTK_ADJUSTMENT (data); g_signal_connect (tool->high_input, "value-changed", G_CALLBACK (levels_high_input_adjustment_update), tool); /* Output levels frame */ frame = gimp_frame_new (_("Output Levels")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox2 = gtk_vbox_new (FALSE, 4); gtk_container_add (GTK_CONTAINER (frame), vbox2); gtk_widget_show (vbox2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0); gtk_widget_show (frame); tool->output_area = gtk_event_box_new (); gtk_widget_set_size_request (tool->output_area, -1, GRADIENT_HEIGHT + CONTROL_HEIGHT); gtk_widget_add_events (bar, LEVELS_EVENT_MASK); gtk_container_add (GTK_CONTAINER (frame), tool->output_area); gtk_widget_show (tool->output_area); g_signal_connect (tool->output_area, "event", G_CALLBACK (levels_output_area_event), tool); g_signal_connect_after (tool->output_area, "expose-event", G_CALLBACK (levels_output_area_expose), tool); vbox3 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (tool->output_area), vbox3); gtk_widget_show (vbox3); tool->output_bar = g_object_new (GIMP_TYPE_COLOR_BAR, "xpad", border, "ypad", 0, NULL); gtk_widget_set_size_request (tool->output_bar, -1, GRADIENT_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox3), tool->output_bar, FALSE, FALSE, 0); gtk_widget_show (tool->output_bar); /* Horizontal box for levels spin widgets */ hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low output spin */ spinbutton = gimp_spin_button_new (&data, 0, 0, 255, 1, 10, 10, 0.5, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->low_output = GTK_ADJUSTMENT (data); g_signal_connect (tool->low_output, "value-changed", G_CALLBACK (levels_low_output_adjustment_update), tool); /* high output spin */ spinbutton = gimp_spin_button_new (&data, 255, 0, 255, 1, 10, 10, 0.5, 0); gtk_box_pack_end (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->high_output = GTK_ADJUSTMENT (data); g_signal_connect (tool->high_output, "value-changed", G_CALLBACK (levels_high_output_adjustment_update), tool); frame = gimp_frame_new (_("All Channels")); gtk_box_pack_end (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); hbox = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); hbbox = gtk_hbutton_box_new (); gtk_box_set_spacing (GTK_BOX (hbbox), 4); gtk_box_pack_start (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0); gtk_widget_show (hbbox); gtk_box_pack_start (GTK_BOX (hbbox), image_map_tool->load_button, FALSE, FALSE, 0); gtk_widget_show (image_map_tool->load_button); gtk_box_pack_start (GTK_BOX (hbbox), image_map_tool->save_button, FALSE, FALSE, 0); gtk_widget_show (image_map_tool->save_button); hbbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_end (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0); gtk_widget_show (hbbox); button = gtk_button_new_with_mnemonic (_("_Auto")); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gimp_help_set_help_data (button, _("Adjust levels automatically"), NULL); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_stretch_callback), tool); button = gimp_levels_tool_color_picker_new (tool, LOW_INPUT | ALL_CHANNELS); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_levels_tool_color_picker_new (tool, GAMMA | ALL_CHANNELS); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_levels_tool_color_picker_new (tool, HIGH_INPUT | ALL_CHANNELS); gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (image_map_tool->shell, "unmap", G_CALLBACK (gimp_levels_tool_dialog_unmap), tool); }
static gboolean shoot_dialog (GdkScreen **screen) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *notebook; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; GtkWidget *toggle; GtkWidget *spinner; GdkPixbuf *pixbuf; GSList *radio_group = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Screenshot"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("S_nap"), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); pixbuf = gdk_pixbuf_new_from_inline (-1, screenshot_icon, FALSE, NULL); if (pixbuf) { gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_pixbuf (pixbuf)); g_object_unref (pixbuf); } main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); /* Hints */ notebook = g_object_new (GTK_TYPE_NOTEBOOK, "show-border", FALSE, "show-tabs", FALSE, NULL); gtk_box_pack_end (GTK_BOX (main_vbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_ROOT, _("After the delay, the screenshot is taken.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_REGION, _("After the delay, drag your mouse to select " "the region for the screenshot.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_WINDOW, _("At the end of the delay, click in a window " "to snap it.")); gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), shootvals.shoot_type); /* Area */ frame = gimp_frame_new (_("Area")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* single window */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "a single _window")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_WINDOW); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_WINDOW)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); #ifdef HAVE_X11_XMU_WINUTIL_H hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gtk_check_button_new_with_mnemonic (_("Include window _decoration")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), shootvals.decorate); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 24); gtk_widget_show (toggle); g_object_set_data (G_OBJECT (button), "set_sensitive", toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &shootvals.decorate); #endif /* HAVE_X11_XMU_WINUTIL_H */ /* whole screen */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "the entire _screen")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_ROOT); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_ROOT)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* dragged region */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Select a _region to grab")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_REGION); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_REGION)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* Delay */ frame = gimp_frame_new (_("Delay")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); spinner = gimp_spin_button_new (&adj, shootvals.select_delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); gtk_widget_show (spinner); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &shootvals.select_delay); /* this is the unit label of a spinbutton */ label = gtk_label_new (_("seconds")); 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); if (run) { /* get the screen on which we are running */ *screen = gtk_widget_get_screen (dialog); } gtk_widget_destroy (dialog); if (run) { /* A short timeout to give the server a chance to * redraw the area that was obscured by our dialog. */ g_timeout_add (100, shoot_quit_timeout, NULL); gtk_main (); } return run; }
static void gimp_histogram_box_init (GimpHistogramBox *box) { GtkWidget *hbox; GtkWidget *vbox; GtkWidget *spinbutton; GtkObject *adjustment; GtkWidget *frame; GtkWidget *view; GtkWidget *bar; GtkWidget *slider_area; gtk_box_set_spacing (GTK_BOX (box), 2); /* The histogram */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 0); gtk_widget_show (frame); view = gimp_histogram_view_new (TRUE); gtk_container_add (GTK_CONTAINER (frame), view); gtk_widget_show (view); g_signal_connect (view, "range-changed", G_CALLBACK (gimp_histogram_box_histogram_range), box); box->view = GIMP_HISTOGRAM_VIEW (view); /* The gradient below the histogram */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 0); gtk_widget_show (frame); box->slider_area = slider_area = gtk_event_box_new (); gtk_widget_set_size_request (slider_area, -1, GRADIENT_HEIGHT + CONTROL_HEIGHT); gtk_widget_add_events (slider_area, HISTOGRAM_EVENT_MASK); gtk_container_add (GTK_CONTAINER (frame), slider_area); gtk_widget_show (slider_area); g_signal_connect (slider_area, "event", G_CALLBACK (gimp_histogram_slider_area_event), box); g_signal_connect_after (slider_area, "expose-event", G_CALLBACK (gimp_histogram_slider_area_expose), box); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (slider_area), vbox); gtk_widget_show (vbox); bar = g_object_new (GIMP_TYPE_COLOR_BAR, "histogram-channel", box->view->channel, "xpad", box->view->border_width, "ypad", box->view->border_width, NULL); gtk_widget_set_size_request (bar, -1, GRADIENT_HEIGHT + 2 * box->view->border_width); gtk_box_pack_start (GTK_BOX (vbox), bar, FALSE, FALSE, 0); gtk_widget_show (bar); g_signal_connect (view, "notify::histogram-channel", G_CALLBACK (gimp_histogram_box_channel_notify), bar); g_signal_connect (view, "notify::border-width", G_CALLBACK (gimp_histogram_box_border_notify), bar); /* The range selection */ hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low spinbutton */ spinbutton = gimp_spin_button_new (&adjustment, 0.0, 0.0, 255.0, 1.0, 16.0, 0.0, 1.0, 0); box->low_adj = GTK_ADJUSTMENT (adjustment); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_histogram_box_low_adj_update), box); /* high spinbutton */ spinbutton = gimp_spin_button_new (&adjustment, 255.0, 0.0, 255.0, 1.0, 16.0, 0.0, 1.0, 0); box->high_adj = GTK_ADJUSTMENT (adjustment); gtk_box_pack_end (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_histogram_box_high_adj_update), box); #ifdef DEBUG_VIEW spinbutton = gimp_prop_spin_button_new (G_OBJECT (box->view), "border-width", 1, 5, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); spinbutton = gimp_prop_spin_button_new (G_OBJECT (box->view), "subdivisions", 1, 5, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); #endif }
static gboolean load_dialog (const gchar *filename) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkObject *adj; guchar *pixels; gboolean run = FALSE; WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION, - WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE }; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Render Windows Metafile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, LOAD_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The WMF preview */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); pixels = wmf_get_pixbuf (filename, &vals.width, &vals.height); image = gimp_preview_area_new (); gtk_widget_set_size_request (image, vals.width, vals.height); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); g_signal_connect (image, "size-allocate", G_CALLBACK (wmf_preview_callback), pixels); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_wmf_size (filename, &vals); wmf_width = vals.width; wmf_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, wmf_width); gimp_size_entry_set_refval (size, 1, wmf_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_width, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small ? does libwmf tend to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); gtk_widget_show (dialog); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); run = TRUE; } gtk_widget_destroy (GTK_WIDGET (dialog)); return run; }
static gint save_dialog (gint32 image_ID) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *spinbutton; GtkObject *adj; GtkWidget *entry; GtkWidget *toggle; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_export_dialog_new (_("HTML table"), PLUG_IN_BINARY, SAVE_PROC); 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 (gimp_export_dialog_get_content_area (dialog)), main_vbox, TRUE, TRUE, 0); if (gimp_image_width (image_ID) * gimp_image_height (image_ID) > 4096) { GtkWidget *eek; GtkWidget *label; GtkWidget *hbox; frame = gimp_frame_new (_("Warning")); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_add (GTK_CONTAINER (frame), hbox); eek = gtk_image_new_from_stock (GIMP_STOCK_WILBER_EEK, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), eek, FALSE, FALSE, 0); label = gtk_label_new (_("You are about to create a huge\n" "HTML file which will most likely\n" "crash your browser.")); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show_all (frame); } /* HTML Page Options */ frame = gimp_frame_new (_("HTML Page Options")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); toggle = gtk_check_button_new_with_mnemonic (_("_Generate full HTML document")); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.fulldoc); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If checked GTM will output a full HTML document " "with <HTML>, <BODY>, etc. tags instead of just " "the table html."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.fulldoc); gtk_widget_show (main_vbox); gtk_widget_show (frame); /* HTML Table Creation Options */ frame = gimp_frame_new (_("Table Creation Options")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); 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); toggle = gtk_check_button_new_with_mnemonic (_("_Use cellspan")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 0, 1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.spantags); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("If checked GTM will replace any rectangular " "sections of identically colored blocks with one " "large cell with ROWSPAN and COLSPAN values."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.spantags); toggle = gtk_check_button_new_with_mnemonic (_("Co_mpress TD tags")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 1, 2, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.tdcomp); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Checking this tag will cause GTM to leave no " "whitespace between the TD tags and the " "cellcontent. This is only necessary for pixel " "level positioning control."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.tdcomp); toggle = gtk_check_button_new_with_mnemonic (_("C_aption")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 2, 3, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), gtmvals.caption); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Check if you would like to have the table " "captioned."), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), >mvals.caption); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.captiontxt); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, 0, 0, 0); gtk_widget_show (entry); gimp_help_set_help_data (entry, _("The text for the table caption."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_caption_callback), NULL); g_object_bind_property (toggle, "active", entry, "sensitive", G_BINDING_SYNC_CREATE); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 200, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.cellcontent); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("C_ell content:"), 0.0, 0.5, entry, 1, FALSE); gtk_widget_show (entry); gimp_help_set_help_data (entry, _("The text to go into each cell."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_cellcontent_callback), NULL); gtk_widget_show (table); gtk_widget_show (frame); /* HTML Table Options */ frame = gimp_frame_new (_("Table Options")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); table = gtk_table_new (5, 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); spinbutton = gimp_spin_button_new (&adj, gtmvals.border, 0, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Border:"), 0.0, 0.5, spinbutton, 1, TRUE); gimp_help_set_help_data (spinbutton, _("The number of pixels in the table border."), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), >mvals.border); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 60, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.clwidth); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, _("_Width:"), 0.0, 0.5, entry, 1, TRUE); gimp_help_set_help_data (entry, _("The width for each table cell. " "Can be a number or a percent."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_clwidth_callback), NULL); entry = gtk_entry_new (); gtk_widget_set_size_request (entry, 60, -1); gtk_entry_set_text (GTK_ENTRY (entry), gtmvals.clheight); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("_Height:"), 0.0, 0.5, entry, 1, TRUE); gimp_help_set_help_data (entry, _("The height for each table cell. " "Can be a number or a percent."), NULL); g_signal_connect (entry, "changed", G_CALLBACK (gtm_clheight_callback), NULL); spinbutton = gimp_spin_button_new (&adj, gtmvals.cellpadding, 0, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Cell-_padding:"), 0.0, 0.5, spinbutton, 1, TRUE); gimp_help_set_help_data (spinbutton, _("The amount of cell padding."), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), >mvals.cellpadding); spinbutton = gimp_spin_button_new (&adj, gtmvals.cellspacing, 0, 1000, 1, 10, 0, 1, 0); gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, _("Cell-_spacing:"), 0.0, 0.5, spinbutton, 1, TRUE); gimp_help_set_help_data (spinbutton, _("The amount of cell spacing."), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), >mvals.cellspacing); gtk_widget_show (table); 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 GtkWidget * print_offset_frame (PrintData *data, GtkSizeGroup *label_group, GtkSizeGroup *entry_group) { GtkWidget *entry; GtkWidget *spinner; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *table; GtkWidget *frame; GtkWidget *label; GtkWidget *combo; frame = gimp_frame_new (_("Position")); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* the offset entry */ entry = GTK_WIDGET (info.size_entry); table = gtk_table_new (4, 4, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 0); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* left */ spinner = gimp_spin_button_new (&info.left_adj, 1, 1, 1, 1, 10, 0, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinner), NULL); gtk_table_attach_defaults (GTK_TABLE (table), spinner, 1, 2, 0, 1); gtk_widget_show (spinner); label = gtk_label_new_with_mnemonic (_("_Left:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1); gtk_size_group_add_widget (label_group, label); gtk_widget_show (label); /* right */ spinner = gimp_spin_button_new (&info.right_adj, 1, 1, 1, 1, 10, 0, 1, 2); g_signal_connect (info.right_adj, "value-changed", G_CALLBACK (print_size_info_offset_max_changed), GINT_TO_POINTER (LEFT)); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinner), NULL); gtk_table_attach_defaults (GTK_TABLE (table), spinner, 3, 4, 0, 1); gtk_widget_show (spinner); label = gtk_label_new_with_mnemonic (_("_Right:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 0, 1); gtk_widget_show (label); /* top */ spinner = gimp_spin_button_new (&info.top_adj, 1, 1, 1, 1, 10, 0, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinner), NULL); gtk_table_attach_defaults (GTK_TABLE (table), spinner, 1, 2, 1, 2); gtk_widget_show (spinner); label = gtk_label_new_with_mnemonic (_("_Top:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2); gtk_size_group_add_widget (label_group, label); gtk_widget_show (label); /* bottom */ spinner = gimp_spin_button_new (&info.bottom_adj, 1, 1, 1, 1, 10, 0, 1, 2); g_signal_connect (info.bottom_adj, "value-changed", G_CALLBACK (print_size_info_offset_max_changed), GINT_TO_POINTER (TOP)); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinner), NULL); gtk_table_attach_defaults (GTK_TABLE (table), spinner, 3, 4, 1, 2); gtk_widget_show (spinner); label = gtk_label_new_with_mnemonic (_("_Bottom:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, 1, 2); gtk_widget_show (label); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), LEFT, 72.0, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), RIGHT, 72.0, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), TOP, 72.0, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), BOTTOM, 72.0, FALSE); print_size_info_update_offsets (); g_signal_connect (info.size_entry, "value-changed", G_CALLBACK (print_size_info_size_changed), NULL); 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 (_("C_enter:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_size_group_add_widget (label_group, label); gtk_widget_show (label); /* if and how to center the image on the page */ combo = gimp_int_combo_box_new (_("None"), CENTER_NONE, _("Horizontally"), CENTER_HORIZONTALLY, _("Vertically"), CENTER_VERTICALLY, _("Both"), CENTER_BOTH, NULL); 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), data->center, G_CALLBACK (print_size_info_center_changed), NULL); info.center_combo = combo; g_signal_connect (info.left_adj, "value-changed", G_CALLBACK (print_size_info_center_none), NULL); g_signal_connect (info.right_adj, "value-changed", G_CALLBACK (print_size_info_center_none), NULL); g_signal_connect (info.top_adj, "value-changed", G_CALLBACK (print_size_info_center_none), NULL); g_signal_connect (info.bottom_adj, "value-changed", G_CALLBACK (print_size_info_center_none), NULL); return frame; }
static gboolean mblur_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *table; GtkWidget *entry; GtkWidget *spinbutton; GtkWidget *label; GtkWidget *button; GtkObject *adj; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Motion Blur"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (mblur), drawable); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Blur Type"), G_CALLBACK (mblur_radio_button_update), &mbvals.mblur_type, mbvals.mblur_type, _("_Linear"), MBLUR_LINEAR, NULL, _("_Radial"), MBLUR_RADIAL, NULL, _("_Zoom"), MBLUR_ZOOM, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); center = gimp_frame_new (_("Blur Center")); gtk_box_pack_start (GTK_BOX (hbox), center, FALSE, FALSE, 0); gtk_widget_show (center); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (center), vbox); gtk_widget_show (vbox); gimp_image_get_resolution (image_ID, &xres, &yres); entry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 5, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); g_signal_connect (entry, "value-changed", G_CALLBACK (mblur_center_update), NULL); g_signal_connect_swapped (entry, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, 1, 0, 1, 1, 10, 1, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, mbvals.center_x); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X:"), 0, 0, 0.0); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, mbvals.center_y); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y:"), 1, 0, 0.0); button = gtk_check_button_new_with_mnemonic (_("Blur _outward")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), mbvals.blur_outward); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &mbvals.blur_outward); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); dir_button = button; frame = gimp_frame_new (_("Blur Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); length = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("L_ength:"), 150, 3, mbvals.length, 1.0, MBLUR_LENGTH_MAX, 1.0, 8.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (length, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.length); g_signal_connect_swapped (length, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); angle = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Angle:"), 150, 3, mbvals.angle, 0.0, 360.0, 1.0, 15.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (angle, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.angle); g_signal_connect_swapped (angle, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); mblur_set_sensitivity (); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gboolean koi_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *main_hbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *alignment; GtkWidget *vbox; GtkWidget *label; GtkWidget *thread_count_spinbutton; GtkObject *thread_count_spinbutton_value; GtkWidget *notebook; int ii; // gui_options.threads = 4; // gui_options.texture_threshold = 140; // gui_options.clone_block_size = 16; // gui_options.histogram_block_size = 8; // gui_options.radius = 20; // gui_options.jpeg_threshold = 64; // gui_options.compress = .85; gboolean run; printf("######################################\n"); printf("############## GUI init ##############\n"); gimp_ui_init ("Koi", FALSE); dialog = gimp_dialog_new ("Koi", "Koi", NULL, 0, gimp_standard_help_func, "Koi", GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); //create plugins and link them into the list create_clone_plugin(); plugin[0] = &clone_plugin; create_grain_plugin(); plugin[1] = &grain_plugin; create_texture_plugin(); plugin[2] = &texture_plugin; create_speckle_plugin(); plugin[3] = &speckle_plugin; create_mosaic_plugin(); plugin[4] = &mosaic_plugin; create_jpeg_plugin(); plugin[5] = &jpeg_plugin; main_vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, (gboolean *)TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 6); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 6, 6, 6); main_hbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (main_hbox); gtk_container_add (GTK_CONTAINER (alignment), main_hbox); //######################################3 //this is where im make my notebook tabs notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_widget_show (notebook); printf("creating tabs\n"); for(ii = 0; ii< NUM_PLUGINS; ii++) { // should make a checkbox with its name will do that later //add the page to the notbook gtk_notebook_append_page (GTK_NOTEBOOK (notebook), plugin[ii]->create_gui(), plugin[ii]->label); } printf("all tabs created\n"); gtk_box_pack_start (GTK_BOX (main_hbox), notebook, FALSE, FALSE, 6); vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); label = gtk_label_new ("Thread count"); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); thread_count_spinbutton = gimp_spin_button_new (&thread_count_spinbutton_value, NUM_THREADS, 0, 16, 1, 1, 0, 1, 0); gtk_widget_show (thread_count_spinbutton); gtk_box_pack_start (GTK_BOX (vbox), thread_count_spinbutton, FALSE, FALSE, 0); // thread_count_spinbutton = gimp_spin_button_new (&thread_count_spinbutton_value, gui_options.threads, 1, 8, 1, 1, 1, 1, 0); // gtk_box_pack_start (GTK_BOX (vbox), thread_count_spinbutton, FALSE, FALSE, 0); // gtk_widget_show (thread_count_spinbutton); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); g_signal_connect_swapped (preview, "invalidated",G_CALLBACK (koi), drawable); koi (drawable, GIMP_PREVIEW (preview)); // g_signal_connect (clone_check_button, "clicked", G_CALLBACK (cb_clone_check_button), &gui_options); g_signal_connect (thread_count_spinbutton_value, "value_changed", G_CALLBACK (gimp_int_adjustment_update), &NUM_THREADS); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
LayerOptionsDialog * layer_options_dialog_new (GimpImage *image, GimpLayer *layer, GimpContext *context, GtkWidget *parent, const gchar *layer_name, GimpFillType layer_fill_type, const gchar *title, const gchar *role, const gchar *stock_id, const gchar *desc, const gchar *help_id) { LayerOptionsDialog *options; GimpViewable *viewable; GtkWidget *vbox; GtkWidget *table; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *button; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); options = g_slice_new0 (LayerOptionsDialog); options->image = image; options->context = context; options->layer = layer; options->fill_type = layer_fill_type; if (layer) viewable = GIMP_VIEWABLE (layer); else viewable = GIMP_VIEWABLE (image); options->dialog = gimp_viewable_dialog_new (viewable, context, title, role, stock_id, desc, parent, gimp_standard_help_func, help_id, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_object_weak_ref (G_OBJECT (options->dialog), (GWeakNotify) layer_options_dialog_free, options); gtk_dialog_set_alternative_button_order (GTK_DIALOG (options->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_set_spacing (GTK_BOX (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (options->dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); table = gtk_table_new (layer ? 1 : 3, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* The name label and entry */ options->name_entry = gtk_entry_new (); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Layer _name:"), 0.0, 0.5, options->name_entry, 1, FALSE); gtk_entry_set_activates_default (GTK_ENTRY (options->name_entry), TRUE); gtk_entry_set_text (GTK_ENTRY (options->name_entry), layer_name); if (! layer) { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); /* The size labels */ 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, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 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, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show (label); /* The size sizeentry */ spinbutton = gimp_spin_button_new (&adjustment, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); options->size_se = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_col_spacing (GTK_TABLE (options->size_se), 1, 4); gtk_table_set_row_spacing (GTK_TABLE (options->size_se), 0, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (options->size_se), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (options->size_se), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gtk_table_attach (GTK_TABLE (table), options->size_se, 1, 2, 1, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (options->size_se); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (options->size_se), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 0, xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 1, yres, FALSE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 0, 0, gimp_image_get_width (image)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 1, 0, gimp_image_get_height (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 0, gimp_image_get_width (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 1, gimp_image_get_height (image)); /* The radio frame */ frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_FILL_TYPE, GIMP_FOREGROUND_FILL, GIMP_TRANSPARENT_FILL, gtk_label_new (_("Layer Fill Type")), G_CALLBACK (gimp_radio_button_update), &options->fill_type, &button); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), options->fill_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } else { GimpContainer *filters; GtkWidget *frame; GtkWidget *view; /* For text layers add a toggle to control "auto-rename" */ if (gimp_item_is_text_layer (GIMP_ITEM (layer))) { options->rename_toggle = gtk_check_button_new_with_mnemonic (_("Set name from _text")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->rename_toggle), GIMP_TEXT_LAYER (layer)->auto_rename); gtk_table_attach (GTK_TABLE (table), options->rename_toggle, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (options->rename_toggle); g_signal_connect (options->rename_toggle, "toggled", G_CALLBACK (layer_options_dialog_toggle_rename), options); } frame = gimp_frame_new ("Active Filters"); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer)); view = gimp_container_tree_view_new (filters, context, GIMP_VIEW_SIZE_SMALL, 0); gtk_container_add (GTK_CONTAINER (frame), view); gtk_widget_show (view); } return options; }
static GimpPDBStatusType load_dialog (const gchar *filename, GError **load_error) { 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_set_error (load_error, error ? error->domain : 0, error ? error->code : 0, _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), error ? error->message : _("Unknown reason")); g_clear_error (&error); return GIMP_PDB_EXECUTION_ERROR; } 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_ROLE, 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_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The SVG preview */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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_box_new (GTK_ORIENTATION_HORIZONTAL, 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, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small, 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_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), load_vals.import); 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); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.import); toggle2 = gtk_check_button_new_with_mnemonic (_("Merge imported paths")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle2), load_vals.merge); gtk_table_attach (GTK_TABLE (table), toggle2, 0, 2, 6, 7, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (toggle2); g_signal_connect (toggle2, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.merge); g_object_bind_property (toggle, "active", toggle2, "sensitive", G_BINDING_SYNC_CREATE); 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 ? GIMP_PDB_SUCCESS : GIMP_PDB_CANCEL; }
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); }
/** * gimp_display_shell_rotate_dialog: * @shell: the #GimpDisplayShell * * Constructs and displays a dialog allowing the user to enter a * custom display rotate. **/ void gimp_display_shell_rotate_dialog (GimpDisplayShell *shell) { RotateDialogData *data; GimpImage *image; GtkWidget *toplevel; GtkWidget *hbox; GtkWidget *spin; GtkWidget *label; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); if (shell->rotate_dialog) { gtk_window_present (GTK_WINDOW (shell->rotate_dialog)); return; } image = gimp_display_get_image (shell->display); data = g_slice_new (RotateDialogData); data->shell = shell; shell->rotate_dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), gimp_get_user_context (shell->display->gimp), _("Rotate View"), "display-rotate", GIMP_STOCK_ROTATE_180, _("Select Rotation Angle"), GTK_WIDGET (shell), gimp_standard_help_func, GIMP_HELP_VIEW_ROTATE_OTHER, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell->rotate_dialog), GTK_RESPONSE_OK, RESPONSE_RESET, -1); g_object_weak_ref (G_OBJECT (shell->rotate_dialog), (GWeakNotify) gimp_display_shell_rotate_dialog_free, data); g_object_add_weak_pointer (G_OBJECT (shell->rotate_dialog), (gpointer) &shell->rotate_dialog); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (shell)); gtk_window_set_transient_for (GTK_WINDOW (shell->rotate_dialog), GTK_WINDOW (toplevel)); gtk_window_set_destroy_with_parent (GTK_WINDOW (shell->rotate_dialog), TRUE); g_signal_connect (shell->rotate_dialog, "response", G_CALLBACK (gimp_display_shell_rotate_dialog_response), data); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell->rotate_dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Angle:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); spin = gimp_spin_button_new ((GtkObject **) &data->rotate_adj, shell->rotate_angle, 0.0, 360.0, 1, 15, 0, 1, 2); gtk_entry_set_activates_default (GTK_ENTRY (spin), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spin, TRUE, TRUE, 0); gtk_widget_show (spin); label = gtk_label_new (_("degrees")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_signal_connect (data->rotate_adj, "value-changed", G_CALLBACK (rotate_adjustment_changed), data); g_signal_connect (shell, "rotated", G_CALLBACK (display_shell_rotated), data); gtk_widget_show (shell->rotate_dialog); }