void create_colorpage (GtkNotebook *notebook) { GtkWidget *vbox; GtkWidget *label, *table; GtkWidget *frame; label = gtk_label_new_with_mnemonic (_("Co_lor")); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Color"), G_CALLBACK (gimp_radio_button_update), &pcvals.color_type, 0, _("A_verage under brush"), COLOR_TYPE_AVERAGE, &colorradio[COLOR_TYPE_AVERAGE], _("C_enter of brush"), COLOR_TYPE_CENTER, &colorradio[COLOR_TYPE_CENTER], NULL); gimp_help_set_help_data (colorradio[COLOR_TYPE_AVERAGE], _("Color is computed from the average of all pixels under the brush"), NULL); gimp_help_set_help_data (colorradio[COLOR_TYPE_CENTER], _("Samples the color from the pixel in the center of the brush"), NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); colornoiseadjust = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Color _noise:"), 100, -1, pcvals.color_noise, 0.0, 100.0, 1.0, 5.0, 0, TRUE, 0, 0, _("Adds random noise to the color"), NULL); g_signal_connect (colornoiseadjust, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &pcvals.color_noise); color_restore (); gtk_notebook_append_page_menu (notebook, vbox, label, NULL); }
GtkWidget * gimp_toolbox_color_area_create (GimpToolbox *toolbox, gint width, gint height) { GimpContext *context; g_return_val_if_fail (GIMP_IS_TOOLBOX (toolbox), NULL); context = gimp_toolbox_get_context (toolbox); color_area = gimp_fg_bg_editor_new (context); gtk_widget_set_size_request (color_area, width, height); gtk_widget_add_events (color_area, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); gimp_help_set_help_data (color_area, _("Foreground & background colors.\n" "The black and white squares reset colors.\n" "The arrows swap colors.\n" "Click to open the color selection dialog."), NULL); g_signal_connect (color_area, "color-clicked", G_CALLBACK (color_area_color_clicked), context); return color_area; }
GtkWidget * gimp_image_map_tool_add_color_picker (GimpImageMapTool *im_tool, gpointer identifier, const gchar *icon_name, const gchar *tooltip) { GtkWidget *button; GtkWidget *image; g_return_val_if_fail (GIMP_IS_IMAGE_MAP_TOOL (im_tool), NULL); g_return_val_if_fail (icon_name != NULL, NULL); button = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "draw-indicator", FALSE, NULL); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_BUTTON); gtk_misc_set_padding (GTK_MISC (image), 2, 2); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); if (tooltip) gimp_help_set_help_data (button, tooltip, NULL); g_object_set_data (G_OBJECT (button), "picker-identifier", identifier); g_signal_connect (button, "toggled", G_CALLBACK (gimp_image_map_tool_color_picker_toggled), im_tool); return button; }
static void gimp_controller_list_select_item (GimpContainerView *view, GimpViewable *viewable, gpointer insert_data, GimpControllerList *list) { gboolean selected; list->dest_info = GIMP_CONTROLLER_INFO (viewable); selected = GIMP_IS_CONTROLLER_INFO (list->dest_info); if (list->remove_button) { GimpObject *object = GIMP_OBJECT (list->dest_info); gchar *tip = NULL; gtk_widget_set_sensitive (list->remove_button, selected); if (selected) tip = g_strdup_printf (_("Remove '%s' from the list of active controllers"), gimp_object_get_name (object)); gimp_help_set_help_data (list->remove_button, tip, NULL); g_free (tip); } gtk_widget_set_sensitive (list->edit_button, selected); gtk_widget_set_sensitive (list->up_button, selected); gtk_widget_set_sensitive (list->down_button, selected); }
static GtkWidget * gimp_text_style_editor_create_toggle (GimpTextStyleEditor *editor, GtkTextTag *tag, const gchar *stock_id, const gchar *tooltip) { GtkWidget *toggle; GtkWidget *image; toggle = gtk_toggle_button_new (); gtk_widget_set_can_focus (toggle, FALSE); gtk_box_pack_start (GTK_BOX (editor->lower_hbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, tooltip, NULL); editor->toggles = g_list_append (editor->toggles, toggle); g_object_set_data (G_OBJECT (toggle), "tag", tag); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_text_style_editor_tag_toggled), editor); image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (toggle), image); gtk_widget_show (image); return toggle; }
/** * gimp_file_entry_new: * @title: The title of the #GtkFileEntry dialog. * @filename: The initial filename. * @dir_only: %TRUE if the file entry should accept directories only. * @check_valid: %TRUE if the widget should check if the entered file * really exists. * * You should use #GtkFileChooserButton instead. * * Returns: A pointer to the new #GimpFileEntry widget. **/ GtkWidget * gimp_file_entry_new (const gchar *title, const gchar *filename, gboolean dir_only, gboolean check_valid) { GimpFileEntry *entry; entry = g_object_new (GIMP_TYPE_FILE_ENTRY, NULL); entry->title = g_strdup (title); entry->dir_only = dir_only; entry->check_valid = check_valid; gimp_help_set_help_data (entry->browse_button, dir_only ? _("Open a file selector to browse your folders") : _("Open a file selector to browse your files"), NULL); if (check_valid) { entry->file_exists = gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_BUTTON); gtk_box_pack_start (GTK_BOX (entry), entry->file_exists, FALSE, FALSE, 0); gtk_widget_show (entry->file_exists); } gimp_file_entry_set_filename (entry, filename); return GTK_WIDGET (entry); }
static void gimp_threshold_tool_dialog (GimpImageMapTool *image_map_tool) { GimpThresholdTool *t_tool = GIMP_THRESHOLD_TOOL (image_map_tool); GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool); GimpThresholdConfig *config = t_tool->config; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *menu; GtkWidget *box; GtkWidget *button; gint n_bins; main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); menu = gimp_prop_enum_icon_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); box = gimp_histogram_box_new (); gtk_box_pack_start (GTK_BOX (main_vbox), box, TRUE, TRUE, 0); gtk_widget_show (box); t_tool->histogram_box = GIMP_HISTOGRAM_BOX (box); n_bins = gimp_histogram_n_bins (t_tool->histogram); gimp_histogram_view_set_range (t_tool->histogram_box->view, config->low * (n_bins - 0.0001), config->high * (n_bins - 0.0001)); g_signal_connect (t_tool->histogram_box->view, "range-changed", G_CALLBACK (gimp_threshold_tool_histogram_range), t_tool); gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options), t_tool->histogram_box->view); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = gtk_button_new_with_mnemonic (_("_Auto")); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gimp_help_set_help_data (button, _("Automatically adjust to optimal " "binarization threshold"), NULL); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_threshold_tool_auto_clicked), t_tool); }
GtkWidget * gimp_toolbox_image_area_create (GimpToolbox *toolbox, gint width, gint height) { GimpContext *context; GtkWidget *image_view; gchar *tooltip; g_return_val_if_fail (GIMP_IS_TOOLBOX (toolbox), NULL); context = gimp_toolbox_get_context (toolbox); image_view = gimp_view_new_full_by_types (context, GIMP_TYPE_VIEW, GIMP_TYPE_IMAGE, width, height, 0, FALSE, TRUE, TRUE); g_signal_connect (image_view, "set-viewable", G_CALLBACK (image_preview_set_viewable), NULL); gimp_view_set_viewable (GIMP_VIEW (image_view), GIMP_VIEWABLE (gimp_context_get_image (context))); gtk_widget_show (image_view); #ifdef GDK_WINDOWING_X11 tooltip = g_strdup_printf ("%s\n%s", _("The active image.\n" "Click to open the Image Dialog."), _("Drag to an XDS enabled file-manager to " "save the image.")); #else tooltip = g_strdup (_("The active image.\n" "Click to open the Image Dialog.")); #endif gimp_help_set_help_data (image_view, tooltip, GIMP_HELP_TOOLBOX_IMAGE_AREA); g_free (tooltip); g_signal_connect_object (context, "image-changed", G_CALLBACK (gimp_view_set_viewable), image_view, G_CONNECT_SWAPPED); g_signal_connect (image_view, "clicked", G_CALLBACK (image_preview_clicked), toolbox); gimp_dnd_viewable_dest_add (image_view, GIMP_TYPE_IMAGE, image_preview_drop_image, context); return image_view; }
static void cdisplay_lcms_update_profile_label (CdisplayLcms *lcms, const gchar *name) { GimpColorConfig *config; GimpColorManaged *managed; GtkWidget *label; GimpColorProfile *profile = NULL; const gchar *text; const gchar *tooltip; config = gimp_color_display_get_config (GIMP_COLOR_DISPLAY (lcms)); managed = gimp_color_display_get_managed (GIMP_COLOR_DISPLAY (lcms)); label = g_object_get_data (G_OBJECT (lcms), name); if (! label) return; if (strcmp (name, "rgb-profile") == 0) { profile = gimp_color_managed_get_color_profile (managed); if (profile) g_object_ref (profile); } else if (g_str_has_prefix (name, "display-profile")) { profile = cdisplay_lcms_get_display_profile (lcms); } else if (strcmp (name, "printer-profile") == 0) { profile = gimp_color_config_get_simulation_color_profile (config, NULL); } else { g_return_if_reached (); } if (profile) { text = gimp_color_profile_get_label (profile); tooltip = gimp_color_profile_get_summary (profile); } else { text = _("None"); tooltip = NULL; } gtk_label_set_text (GTK_LABEL (label), text); gimp_help_set_help_data (label, tooltip, NULL); if (profile) g_object_unref (profile); }
static void gimp_action_set_proxy_tooltip (GimpAction *action, GtkWidget *proxy) { const gchar *tooltip = gtk_action_get_tooltip (GTK_ACTION (action)); if (tooltip) gimp_help_set_help_data (proxy, tooltip, g_object_get_qdata (G_OBJECT (proxy), GIMP_HELP_ID)); }
void select_border_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; GtkWidget *dialog; GtkWidget *button; gdouble xres; gdouble yres; return_if_no_display (display, data); image = gimp_display_get_image (display); gimp_image_get_resolution (image, &xres, &yres); dialog = gimp_query_size_box (_("Border Selection"), GTK_WIDGET (gimp_display_get_shell (display)), gimp_standard_help_func, GIMP_HELP_SELECTION_BORDER, _("Border selection by"), select_border_radius, 1, 32767, 0, gimp_display_get_shell (display)->unit, MIN (xres, yres), FALSE, G_OBJECT (image), "disconnect", select_border_callback, image); /* Feather button */ button = gtk_check_button_new_with_mnemonic (_("_Feather border")); gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dialog), "border-feather-toggle", button); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), select_border_feather); gtk_widget_show (button); /* Edge lock button */ button = gtk_check_button_new_with_mnemonic (_("_Selected areas continue outside the image")); g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button); gimp_help_set_help_data (button, _("When bordering, act as if selected areas " "continued outside the image."), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), select_border_edge_lock); gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_widget_show (dialog); }
static void gimp_widget_accel_changed (GtkAccelGroup *accel_group, guint unused1, GdkModifierType unused2, GClosure *accel_closure, GtkWidget *widget) { GClosure *widget_closure; widget_closure = g_object_get_data (G_OBJECT (widget), "gimp-accel-closure"); if (accel_closure == widget_closure) { GtkAction *action; GtkAccelKey *accel_key; gchar *orig_tooltip; gchar *tooltip; const gchar *help_id; action = g_object_get_data (G_OBJECT (widget), "gimp-accel-action"); g_object_get (action, "tooltip", &orig_tooltip, NULL); help_id = g_object_get_qdata (G_OBJECT (action), GIMP_HELP_ID); accel_key = gtk_accel_group_find (accel_group, gimp_widget_accel_find_func, accel_closure); if (accel_key && accel_key->accel_key && accel_key->accel_flags & GTK_ACCEL_VISIBLE) { gchar *accel = gtk_accelerator_get_label (accel_key->accel_key, accel_key->accel_mods); tooltip = g_strdup_printf ("%s (%s)", orig_tooltip, accel); g_free (accel); } else { tooltip = g_strdup (orig_tooltip); } gimp_help_set_help_data (widget, tooltip, help_id); g_free (tooltip); g_free (orig_tooltip); } }
static void gimp_pick_button_init (GimpPickButton *button) { GtkWidget *image; image = gtk_image_new_from_stock (GIMP_STOCK_COLOR_PICK_FROM_SCREEN, GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); gimp_help_set_help_data (GTK_WIDGET (button), _("Click the eyedropper, then click a color " "anywhere on your screen to select that color."), NULL); }
static void gimp_widget_accel_changed (GtkAccelGroup *accel_group, guint unused1, GdkModifierType unused2, GClosure *accel_closure, GtkWidget *widget) { GClosure *widget_closure; widget_closure = g_object_get_data (G_OBJECT (widget), "gimp-accel-closure"); if (accel_closure == widget_closure) { GtkAction *action; GtkAccelKey *accel_key; const gchar *tooltip; const gchar *help_id; action = g_object_get_data (G_OBJECT (widget), "gimp-accel-action"); tooltip = gtk_action_get_tooltip (action); help_id = g_object_get_qdata (G_OBJECT (action), GIMP_HELP_ID); accel_key = gtk_accel_group_find (accel_group, gimp_widget_accel_find_func, accel_closure); if (accel_key && accel_key->accel_key && accel_key->accel_flags & GTK_ACCEL_VISIBLE) { gchar *escaped = g_markup_escape_text (tooltip, -1); gchar *accel = gtk_accelerator_get_label (accel_key->accel_key, accel_key->accel_mods); gchar *tmp = g_strdup_printf ("%s <b>%s</b>", escaped, accel); g_free (accel); g_free (escaped); gimp_help_set_help_data_with_markup (widget, tmp, help_id); g_free (tmp); } else { gimp_help_set_help_data (widget, tooltip, help_id); } } }
static GtkWidget * gimp_levels_tool_color_picker_new (GimpLevelsTool *tool, guint value) { GtkWidget *button; GtkWidget *image; const gchar *stock_id; const gchar *help; switch (value & 0xF) { case PICK_LOW_INPUT: stock_id = GIMP_STOCK_COLOR_PICKER_BLACK; help = _("Pick black point"); break; case PICK_GAMMA: stock_id = GIMP_STOCK_COLOR_PICKER_GRAY; help = _("Pick gray point"); break; case PICK_HIGH_INPUT: stock_id = GIMP_STOCK_COLOR_PICKER_WHITE; help = _("Pick white point"); break; default: return NULL; } button = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "draw-indicator", FALSE, NULL); image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON); gtk_misc_set_padding (GTK_MISC (image), 2, 2); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); gimp_help_set_help_data (button, help, NULL); g_object_set_data (G_OBJECT (button), "pick-value", GUINT_TO_POINTER (value)); g_signal_connect (button, "toggled", G_CALLBACK (levels_input_picker_toggled), tool); return button; }
/* The main GUI function for saving single-paged PDFs */ static gboolean gui_single (void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *vectorize_c; GtkWidget *ignore_hidden_c; GtkWidget *apply_c; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_PROC); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (window), 12); ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden); gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, TRUE, TRUE, 0); vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize); gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, TRUE, TRUE, 0); apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks); gtk_box_pack_end (GTK_BOX (vbox), apply_c, TRUE, TRUE, 0); gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL); gtk_widget_show_all (window); run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK; optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c)); optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c)); optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c)); gtk_widget_destroy (window); return run; }
static void gimp_image_prop_view_label_set_filename (GtkWidget *label, GimpImage *image) { GFile *file = gimp_image_get_any_file (image); if (file) { gtk_label_set_text (GTK_LABEL (label), gimp_file_get_utf8_name (file)); } else { gtk_label_set_text (GTK_LABEL (label), NULL); gimp_help_set_help_data (gtk_widget_get_parent (label), NULL, NULL); } }
GtkWidget * gimp_editor_add_button (GimpEditor *editor, const gchar *stock_id, const gchar *tooltip, const gchar *help_id, GCallback callback, GCallback extended_callback, gpointer callback_data) { GtkWidget *button; GtkWidget *image; GtkIconSize button_icon_size; GtkReliefStyle button_relief; g_return_val_if_fail (GIMP_IS_EDITOR (editor), NULL); g_return_val_if_fail (stock_id != NULL, NULL); button_icon_size = gimp_editor_ensure_button_box (editor, &button_relief); button = g_object_new (GIMP_TYPE_BUTTON, "use-stock", TRUE, NULL); gtk_button_set_relief (GTK_BUTTON (button), button_relief); gtk_box_pack_start (GTK_BOX (editor->button_box), button, TRUE, TRUE, 0); gtk_widget_show (button); if (tooltip || help_id) gimp_help_set_help_data (button, tooltip, help_id); if (callback) g_signal_connect (button, "clicked", callback, callback_data); if (extended_callback) g_signal_connect (button, "extended-clicked", extended_callback, callback_data); image = gtk_image_new_from_stock (stock_id, button_icon_size); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); return button; }
static void gimp_image_prop_view_label_set_filename (GtkWidget *label, GimpImage *image) { const gchar *uri = gimp_image_get_any_uri (image); if (uri) { gchar *name = file_utils_uri_display_name (uri); gtk_label_set_text (GTK_LABEL (label), name); g_free (name); } else { gtk_label_set_text (GTK_LABEL (label), NULL); gimp_help_set_help_data (gtk_widget_get_parent (label), NULL, NULL); } }
static void cdisplay_lcms_update_profile_label (CdisplayLcms *lcms, const gchar *name) { GtkWidget *label; cmsHPROFILE profile = NULL; gchar *text = NULL; gchar *tooltip = NULL; label = g_object_get_data (G_OBJECT (lcms), name); if (! label) return; if (strcmp (name, "rgb-profile") == 0) { profile = cdisplay_lcms_get_rgb_profile (lcms); } else if (g_str_has_prefix (name, "display-profile")) { profile = cdisplay_lcms_get_display_profile (lcms); } else if (strcmp (name, "printer-profile") == 0) { profile = cdisplay_lcms_get_printer_profile (lcms); } else { g_return_if_reached (); } cdisplay_lcms_profile_get_info (profile, &text, &tooltip); gtk_label_set_text (GTK_LABEL (label), text); gimp_help_set_help_data (label, tooltip, NULL); g_free (text); g_free (tooltip); if (profile) cmsCloseProfile (profile); }
/** * gimp_help_connect: * @widget: The widget you want to connect the help accelerator for. Will * be a #GtkWindow in most cases. * @help_func: The function which will be called if the user presses "F1". * @help_id: The @help_id which will be passed to @help_func. * @help_data: The @help_data pointer which will be passed to @help_func. * * Note that this function is automatically called by all libgimp dialog * constructors. You only have to call it for windows/dialogs you created * "manually". **/ void gimp_help_connect (GtkWidget *widget, GimpHelpFunc help_func, const gchar *help_id, gpointer help_data) { static gboolean initialized = FALSE; g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (help_func != NULL); /* set up the help signals */ if (! initialized) { GtkBindingSet *binding_set; binding_set = gtk_binding_set_by_class (g_type_class_peek (GTK_TYPE_WIDGET)); gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, 0, "show-help", 1, GTK_TYPE_WIDGET_HELP_TYPE, GIMP_WIDGET_HELP_TYPE_HELP); gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_F1, 0, "show-help", 1, GTK_TYPE_WIDGET_HELP_TYPE, GIMP_WIDGET_HELP_TYPE_HELP); initialized = TRUE; } gimp_help_set_help_data (widget, NULL, help_id); g_object_set_data (G_OBJECT (widget), "gimp-help-data", help_data); g_signal_connect (widget, "show-help", G_CALLBACK (gimp_help_callback), help_func); gtk_widget_add_events (widget, GDK_BUTTON_PRESS_MASK); }
void gimp_widget_set_accel_help (GtkWidget *widget, GtkAction *action) { GClosure *accel_closure = NULL; accel_closure = gtk_action_get_accel_closure (action); if (accel_closure) { GtkAccelGroup *accel_group; g_object_set_data (G_OBJECT (widget), "gimp-accel-closure", accel_closure); g_object_set_data (G_OBJECT (widget), "gimp-accel-action", action); accel_group = gtk_accel_group_from_accel_closure (accel_closure); g_signal_connect_object (accel_group, "accel-changed", G_CALLBACK (gimp_widget_accel_changed), widget, 0); gimp_widget_accel_changed (accel_group, 0, 0, accel_closure, widget); } else { gchar *tooltip; gchar *help_id; g_object_get (action, "tooltip", &tooltip, NULL); help_id = g_object_get_qdata (G_OBJECT (action), GIMP_HELP_ID); gimp_help_set_help_data (widget, tooltip, help_id); g_free (tooltip); } }
static void gimp_controller_list_src_sel_changed (GtkTreeSelection *sel, GimpControllerList *list) { GtkTreeModel *model; GtkTreeIter iter; gchar *tip = NULL; if (gtk_tree_selection_get_selected (sel, &model, &iter)) { gchar *name; gtk_tree_model_get (model, &iter, COLUMN_NAME, &name, COLUMN_TYPE, &list->src_gtype, -1); if (list->add_button) { tip = g_strdup_printf (_("Add '%s' to the list of active controllers"), name); gtk_widget_set_sensitive (list->add_button, TRUE); } g_free (name); } else { if (list->add_button) gtk_widget_set_sensitive (list->add_button, FALSE); } if (list->add_button) { gimp_help_set_help_data (list->add_button, tip, NULL); g_free (tip); } }
/* * Creates a radio button. * box - the containing box. * orient_type - The orientation ID * label, help_string - self-describing * radio_group - * A pointer to a radio group. The function assigns its value * as the radio group of the radio button. Afterwards, it assigns it * a new value of the new radio group of the button. * This is useful to group buttons. Just reset the variable to NULL, * to create a new group. * */ GtkWidget * create_radio_button (GtkWidget *box, int orient_type, void (*callback) (GtkWidget *wg, void *d), gchar *label, gchar *help_string, GSList **radio_group, GtkWidget **buttons_array) { GtkWidget *tmpw; buttons_array[orient_type] = tmpw = gtk_radio_button_new_with_label ((*radio_group), label); gtk_box_pack_start (GTK_BOX (box), tmpw, FALSE, FALSE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (callback), GINT_TO_POINTER (orient_type)); gimp_help_set_help_data (tmpw, help_string, NULL); *radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (tmpw)); return tmpw; }
/* The main GUI function for saving multi-paged PDFs */ static gboolean gui_multi (void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *file_label; GtkWidget *file_entry; GtkWidget *file_browse; GtkWidget *file_hbox; GtkWidget *vectorize_c; GtkWidget *ignore_hidden_c; GtkWidget *apply_c; GtkWidget *scroll; GtkWidget *page_view; GtkWidget *h_but_box; GtkWidget *del; GtkWidget *h_box; GtkWidget *img_combo; GtkWidget *add_image; gboolean run; const gchar *temp; gimp_ui_init (PLUG_IN_BINARY, FALSE); window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_MULTI_PROC); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (window), 12); file_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); file_label = gtk_label_new (_("Save to:")); file_entry = gtk_entry_new (); if (file_name != NULL) gtk_entry_set_text (GTK_ENTRY (file_entry), file_name); file_browse = gtk_button_new_with_label (_("Browse...")); file_choose = gtk_file_chooser_dialog_new (_("Multipage PDF export"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE, "gtk-save", GTK_RESPONSE_OK, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL); gtk_box_pack_start (GTK_BOX (file_hbox), file_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (file_hbox), file_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (file_hbox), file_browse, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), file_hbox, TRUE, TRUE, 0); page_view = gtk_icon_view_new (); model = create_model (); gtk_icon_view_set_model (GTK_ICON_VIEW (page_view), model); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (page_view), TRUE); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (page_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (page_view), THUMB); gtk_icon_view_set_text_column (GTK_ICON_VIEW (page_view), PAGE_NUMBER); gtk_icon_view_set_tooltip_column (GTK_ICON_VIEW (page_view), IMAGE_NAME); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (scroll, -1, 300); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scroll), page_view); gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); h_but_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (h_but_box), GTK_BUTTONBOX_START); del = gtk_button_new_with_label (_("Remove the selected pages")); gtk_box_pack_start (GTK_BOX (h_but_box), del, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), h_but_box, FALSE, FALSE, 0); h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); img_combo = gimp_image_combo_box_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (h_box), img_combo, FALSE, FALSE, 0); add_image = gtk_button_new_with_label (_("Add this image")); gtk_box_pack_start (GTK_BOX (h_box), add_image, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), h_box, FALSE, FALSE, 0); ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden); gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, FALSE, FALSE, 0); vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize); gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, FALSE, FALSE, 0); apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks); gtk_box_pack_end (GTK_BOX (vbox), apply_c, FALSE, FALSE, 0); gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL); gtk_widget_show_all (window); g_signal_connect (G_OBJECT (file_browse), "clicked", G_CALLBACK (choose_file_call), G_OBJECT (file_entry)); g_signal_connect (G_OBJECT (add_image), "clicked", G_CALLBACK (add_image_call), G_OBJECT (img_combo)); g_signal_connect (G_OBJECT (del), "clicked", G_CALLBACK (del_image_call), G_OBJECT (page_view)); g_signal_connect (G_OBJECT (model), "row-deleted", G_CALLBACK (remove_call), NULL); run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK; run &= get_image_list (); temp = gtk_entry_get_text (GTK_ENTRY (file_entry)); g_stpcpy (file_name, temp); optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c)); optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c)); optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c)); gtk_widget_destroy (window); return run; }
static gboolean load_dialog (const gchar *filename) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkObject *adj; guchar *pixels; gboolean run = FALSE; WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION, - WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE }; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Render Windows Metafile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, LOAD_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The WMF preview */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); pixels = wmf_get_pixbuf (filename, &vals.width, &vals.height); image = gimp_preview_area_new (); gtk_widget_set_size_request (image, vals.width, vals.height); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); g_signal_connect (image, "size-allocate", G_CALLBACK (wmf_preview_callback), pixels); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_wmf_size (filename, &vals); wmf_width = vals.width; wmf_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, wmf_width); gimp_size_entry_set_refval (size, 1, wmf_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_width, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small ? does libwmf tend to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); gtk_widget_show (dialog); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); run = TRUE; } gtk_widget_destroy (GTK_WIDGET (dialog)); return run; }
static void gimp_text_style_editor_init (GimpTextStyleEditor *editor) { GtkWidget *image; GimpRGB color; gtk_orientable_set_orientation (GTK_ORIENTABLE (editor), GTK_ORIENTATION_VERTICAL); gtk_box_set_spacing (GTK_BOX (editor), 2); /* upper row */ editor->upper_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (editor), editor->upper_hbox, FALSE, FALSE, 0); gtk_widget_show (editor->upper_hbox); editor->font_entry = gimp_container_entry_new (NULL, NULL, GIMP_VIEW_SIZE_SMALL, 1); gtk_box_pack_start (GTK_BOX (editor->upper_hbox), editor->font_entry, FALSE, FALSE, 0); gtk_widget_show (editor->font_entry); gimp_help_set_help_data (editor->font_entry, _("Change font of selected text"), NULL); editor->size_entry = gimp_size_entry_new (1, 0, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_col_spacing (GTK_TABLE (editor->size_entry), 1, 0); gtk_box_pack_start (GTK_BOX (editor->upper_hbox), editor->size_entry, FALSE, FALSE, 0); gtk_widget_show (editor->size_entry); gimp_help_set_help_data (editor->size_entry, _("Change size of selected text"), NULL); g_signal_connect (editor->size_entry, "value-changed", G_CALLBACK (gimp_text_style_editor_size_changed), editor); /* lower row */ editor->lower_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (editor), editor->lower_hbox, FALSE, FALSE, 0); gtk_widget_show (editor->lower_hbox); editor->clear_button = gtk_button_new (); gtk_widget_set_can_focus (editor->clear_button, FALSE); gtk_box_pack_start (GTK_BOX (editor->lower_hbox), editor->clear_button, FALSE, FALSE, 0); gtk_widget_show (editor->clear_button); gimp_help_set_help_data (editor->clear_button, _("Clear style of selected text"), NULL); g_signal_connect (editor->clear_button, "clicked", G_CALLBACK (gimp_text_style_editor_clear_tags), editor); image = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (editor->clear_button), image); gtk_widget_show (image); gimp_rgba_set (&color, 0.0, 0.0, 0.0, 1.0); editor->color_button = gimp_color_panel_new (_("Change color of selected text"), &color, GIMP_COLOR_AREA_FLAT, 20, 20); gtk_box_pack_end (GTK_BOX (editor->lower_hbox), editor->color_button, FALSE, FALSE, 0); gtk_widget_show (editor->color_button); gimp_help_set_help_data (editor->color_button, _("Change color of selected text"), NULL); g_signal_connect (editor->color_button, "color-changed", G_CALLBACK (gimp_text_style_editor_color_changed), editor); editor->kerning_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, -1000.0, 1000.0, 1.0, 10.0, 0.0)); editor->kerning_spinbutton = gtk_spin_button_new (editor->kerning_adjustment, 1.0, 1); gtk_entry_set_width_chars (GTK_ENTRY (editor->kerning_spinbutton), 5); gtk_box_pack_end (GTK_BOX (editor->lower_hbox), editor->kerning_spinbutton, FALSE, FALSE, 0); gtk_widget_show (editor->kerning_spinbutton); gimp_help_set_help_data (editor->kerning_spinbutton, _("Change kerning of selected text"), NULL); g_signal_connect (editor->kerning_adjustment, "value-changed", G_CALLBACK (gimp_text_style_editor_kerning_changed), editor); editor->baseline_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, -1000.0, 1000.0, 1.0, 10.0, 0.0)); editor->baseline_spinbutton = gtk_spin_button_new (editor->baseline_adjustment, 1.0, 1); gtk_entry_set_width_chars (GTK_ENTRY (editor->baseline_spinbutton), 5); gtk_box_pack_end (GTK_BOX (editor->lower_hbox), editor->baseline_spinbutton, FALSE, FALSE, 0); gtk_widget_show (editor->baseline_spinbutton); gimp_help_set_help_data (editor->baseline_spinbutton, _("Change baseline of selected text"), NULL); g_signal_connect (editor->baseline_adjustment, "value-changed", G_CALLBACK (gimp_text_style_editor_baseline_changed), editor); }
GtkWidget * gimp_paint_options_gui (GimpToolOptions *tool_options) { GObject *config = G_OBJECT (tool_options); GimpPaintOptions *options = GIMP_PAINT_OPTIONS (tool_options); GtkWidget *vbox = gimp_tool_options_gui (tool_options); GtkWidget *hbox; GtkWidget *menu; GtkWidget *label; GtkWidget *scale; GType tool_type; tool_type = tool_options->tool_info->tool_type; /* the paint mode menu */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("Mode:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); menu = gimp_prop_paint_mode_menu_new (config, "paint-mode", TRUE, FALSE); gtk_box_pack_start (GTK_BOX (hbox), menu, TRUE, TRUE, 0); gtk_widget_show (menu); if (tool_type == GIMP_TYPE_ERASER_TOOL || tool_type == GIMP_TYPE_CONVOLVE_TOOL || tool_type == GIMP_TYPE_DODGE_BURN_TOOL || tool_type == GIMP_TYPE_SMUDGE_TOOL) { gtk_widget_set_sensitive (menu, FALSE); gtk_widget_set_sensitive (label, FALSE); } /* the opacity scale */ scale = gimp_prop_opacity_spin_scale_new (config, "opacity", _("Opacity")); gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0); gtk_widget_show (scale); /* the brush */ if (g_type_is_a (tool_type, GIMP_TYPE_BRUSH_TOOL)) { GtkWidget *button; GtkWidget *hbox; GtkWidget *frame; button = gimp_prop_brush_box_new (NULL, GIMP_CONTEXT (tool_options), _("Brush"), 2, "brush-view-type", "brush-view-size", "gimp-brush-editor"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-size", _("Size"), 0.01, 1.0, 2); gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0); gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_size), options); gimp_help_set_help_data (button, _("Reset size to brush's native size"), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-aspect-ratio", _("Aspect Ratio"), 0.01, 0.1, 2); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio), options); gimp_help_set_help_data (button, _("Reset aspect ratio to brush's native"), NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); scale = gimp_prop_spin_scale_new (config, "brush-angle", _("Angle"), 1.0, 5.0, 2); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_widget_show (scale); button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))), GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (gimp_paint_options_gui_reset_angle), options); gimp_help_set_help_data (button, _("Reset angle to zero"), NULL); button = gimp_prop_dynamics_box_new (NULL, GIMP_CONTEXT (tool_options), _("Dynamics"), 2, "dynamics-view-type", "dynamics-view-size", "gimp-dynamics-editor"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); frame = dynamics_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); frame = jitter_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } /* the "smooth stroke" options */ if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL)) { GtkWidget *frame; frame = smoothing_options_gui (options, tool_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } /* the "incremental" toggle */ if (tool_type == GIMP_TYPE_PENCIL_TOOL || tool_type == GIMP_TYPE_PAINTBRUSH_TOOL || tool_type == GIMP_TYPE_ERASER_TOOL) { GtkWidget *button; button = gimp_prop_enum_check_button_new (config, "application-mode", _("Incremental"), GIMP_PAINT_CONSTANT, GIMP_PAINT_INCREMENTAL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } /* the "hard edge" toggle */ if (tool_type == GIMP_TYPE_ERASER_TOOL || tool_type == GIMP_TYPE_CLONE_TOOL || tool_type == GIMP_TYPE_HEAL_TOOL || tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL || tool_type == GIMP_TYPE_CONVOLVE_TOOL || tool_type == GIMP_TYPE_DODGE_BURN_TOOL || tool_type == GIMP_TYPE_SMUDGE_TOOL) { GtkWidget *button; button = gimp_prop_check_button_new (config, "hard", _("Hard edge")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); } return vbox; }
void create_orientmap_dialog (GtkWidget *parent) { GtkWidget *tmpw, *tmpw2; GtkWidget *table1, *table2; GtkWidget *frame; GtkWidget *ebox, *hbox, *vbox; init_vectors (); if (orient_map_window) { update_vector_prev (); update_orient_map_preview_prev (); gtk_widget_show (orient_map_window); return; } orient_map_window = gimp_dialog_new (_("Orientation Map Editor"), PLUG_IN_BINARY, gtk_widget_get_toplevel (parent), 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (orient_map_window), GTK_RESPONSE_OK, GTK_RESPONSE_APPLY, GTK_RESPONSE_CANCEL, -1); g_signal_connect (orient_map_window, "response", G_CALLBACK (orient_map_response), orient_map_window); g_signal_connect (orient_map_window, "destroy", G_CALLBACK (gtk_widget_destroyed), &orient_map_window); table1 = gtk_table_new (2, 5, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table1), 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (orient_map_window))), table1, TRUE, TRUE, 0); gtk_widget_show (table1); frame = gtk_frame_new (_("Vectors")); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_table_attach (GTK_TABLE (table1), frame, 0, 1, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0); gtk_widget_show (frame); hbox = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); ebox = gtk_event_box_new (); gimp_help_set_help_data (ebox, _("The vector-field. " "Left-click to move selected vector, " "Right-click to point it towards mouse, " "Middle-click to add a new vector."), NULL); gtk_box_pack_start (GTK_BOX (hbox), ebox, FALSE, FALSE, 0); tmpw = vector_preview = gimp_preview_area_new (); gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT); gtk_container_add (GTK_CONTAINER (ebox), tmpw); gtk_widget_show (tmpw); gtk_widget_add_events (ebox, GDK_BUTTON_PRESS_MASK); g_signal_connect (ebox, "button-press-event", G_CALLBACK (map_click_callback), NULL); gtk_widget_show (ebox); vector_preview_brightness_adjust = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 1.0, 1.0); tmpw = gtk_vscale_new (GTK_ADJUSTMENT (vector_preview_brightness_adjust)); gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, FALSE,0); gtk_widget_show (tmpw); g_signal_connect (vector_preview_brightness_adjust, "value-changed", G_CALLBACK (update_vector_prev), NULL); gimp_help_set_help_data (tmpw, _("Adjust the preview's brightness"), NULL); tmpw2 = tmpw = gtk_frame_new (_("Preview")); gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2); gtk_table_attach (GTK_TABLE (table1), tmpw, 1,2, 0,1, GTK_EXPAND, GTK_EXPAND, 0, 0); gtk_widget_show (tmpw); tmpw = orient_map_preview_prev = gimp_preview_area_new (); gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT);; gtk_container_add (GTK_CONTAINER (tmpw2), tmpw); gtk_widget_show (tmpw); hbox = tmpw = gtk_hbox_new (TRUE,0); gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2); gtk_table_attach_defaults (GTK_TABLE (table1), tmpw, 0,1, 1,2); gtk_widget_show (tmpw); prev_button = tmpw = gtk_button_new_with_mnemonic ("_<<"); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (prev_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Select previous vector"), NULL); next_button = tmpw = gtk_button_new_with_mnemonic ("_>>"); gtk_box_pack_start (GTK_BOX (hbox),tmpw,FALSE,TRUE,0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (next_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Select next vector"), NULL); add_button = tmpw = gtk_button_new_with_mnemonic ( _("A_dd")); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (add_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Add new vector"), NULL); kill_button = tmpw = gtk_button_new_with_mnemonic ( _("_Kill")); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (delete_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Delete selected vector"), NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_box_set_spacing (GTK_BOX (hbox), 12); gtk_table_attach_defaults (GTK_TABLE (table1), hbox, 0, 2, 2, 3); gtk_widget_show (hbox); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Type"), G_CALLBACK (vector_type_click_callback), &vector_type, 0, _("_Normal"), 0, &vector_types[0], _("Vorte_x"), 1, &vector_types[1], _("Vortex_2"), 2, &vector_types[2], _("Vortex_3"), 3, &vector_types[3], NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); orient_voronoi = tmpw = gtk_check_button_new_with_mnemonic ( _("_Voronoi")); gtk_box_pack_start (GTK_BOX (vbox), tmpw, TRUE, TRUE, 0); gtk_widget_show (tmpw); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.orient_voronoi); g_signal_connect (tmpw, "clicked", G_CALLBACK (angle_offset_adjust_move_callback), NULL); gimp_help_set_help_data (tmpw, _("Voronoi-mode makes only the vector closest to the given point have any influence"), NULL); table2 = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table2), 4); gtk_box_pack_start (GTK_BOX (hbox), table2, TRUE, TRUE, 0); gtk_widget_show (table2); angle_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 0, _("A_ngle:"), 150, 6, 0.0, 0.0, 360.0, 1.0, 10.0, 1, TRUE, 0, 0, _("Change the angle of the selected vector"), NULL); g_signal_connect (angle_adjust, "value-changed", G_CALLBACK (angle_adjust_move_callback), NULL); angle_offset_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 1, _("Ang_le offset:"), 150, 6, 0.0, 0.0, 360.0, 1.0, 10.0, 1, TRUE, 0, 0, _("Offset all vectors with a given angle"), NULL); g_signal_connect (angle_offset_adjust, "value-changed", G_CALLBACK (angle_offset_adjust_move_callback), NULL); strength_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 2, _("_Strength:"), 150, 6, 1.0, 0.1, 5.0, 0.1, 1.0, 1, TRUE, 0, 0, _("Change the strength of the selected vector"), NULL); g_signal_connect (strength_adjust, "value-changed", G_CALLBACK (strength_adjust_move_callback), NULL); orient_map_str_exp_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 3, _("S_trength exp.:"), 150, 6, 1.0, 0.1, 10.9, 0.1, 1.0, 1, TRUE, 0, 0, _("Change the exponent of the strength"), NULL); g_signal_connect (orient_map_str_exp_adjust, "value-changed", G_CALLBACK (strength_exponent_adjust_move_callback), NULL); gtk_widget_show (orient_map_window); update_vector_prev (); update_orient_map_preview_prev (); }
static gboolean decompose_dialog (void) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *combo; GtkWidget *toggle; gint j; gint extract_idx; gboolean run; extract_idx = 0; for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (extract[j].dialog && g_ascii_strcasecmp (decovals.extract_type, extract[j].type) == 0) { extract_idx = j; break; } } gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Decompose"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); frame = gimp_frame_new (_("Extract Channels")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Color _model:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL); for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (extract[j].dialog) { gchar *label = g_strdup (gettext (extract[j].type)); gchar *l; for (l = label; *l; l++) if (*l == '-' || *l == '_') *l = ' '; gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_LABEL, label, GIMP_INT_STORE_VALUE, j, -1); g_free (label); } } gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), extract_idx, G_CALLBACK (gimp_int_combo_box_get_active), &extract_idx); toggle = gtk_check_button_new_with_mnemonic (_("_Decompose to layers")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), decovals.as_layers); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &decovals.as_layers); toggle = gtk_check_button_new_with_mnemonic (_("_Foreground as registration color")); gimp_help_set_help_data (toggle, _("Pixels in the foreground color will " "appear black in all output images. " "This can be used for things like crop " "marks that have to show up on all " "channels."), PLUG_IN_PROC); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), decovals.use_registration); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &decovals.use_registration); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); if (run) strncpy (decovals.extract_type, extract[extract_idx].type, sizeof decovals.extract_type - 1); return run; }