void gimp_color_tool_start_sample_point (GimpTool *tool, GimpDisplay *display) { GimpColorTool *color_tool; g_return_if_fail (GIMP_IS_COLOR_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); color_tool = GIMP_COLOR_TOOL (tool); gimp_display_shell_selection_control (GIMP_DISPLAY_SHELL (display->shell), GIMP_SELECTION_PAUSE); tool->display = display; gimp_tool_control_activate (tool->control); if (color_tool->sample_point) gimp_display_shell_draw_sample_point (GIMP_DISPLAY_SHELL (display->shell), color_tool->sample_point, FALSE); color_tool->sample_point = NULL; color_tool->moving_sample_point = TRUE; color_tool->sample_point_x = -1; color_tool->sample_point_y = -1; gimp_tool_set_cursor (tool, display, GIMP_CURSOR_MOUSE, GIMP_TOOL_CURSOR_COLOR_PICKER, GIMP_CURSOR_MODIFIER_MOVE); gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); }
static void gimp_display_shell_drop_buffer (GtkWidget *widget, gint drop_x, gint drop_y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = gimp_display_get_image (shell->display); GimpDrawable *drawable; GimpBuffer *buffer; gint x, y, width, height; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { image = gimp_image_new_from_buffer (shell->display->gimp, NULL, GIMP_BUFFER (viewable)); gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0); g_object_unref (image); return; } drawable = gimp_image_get_active_drawable (image); if (drawable) { if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Cannot modify the pixels of layer groups.")); return; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("The active layer's pixels are locked.")); return; } } buffer = GIMP_BUFFER (viewable); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); /* FIXME: popup a menu for selecting "Paste Into" */ gimp_edit_paste (image, drawable, buffer, FALSE, x, y, width, height); gimp_display_shell_dnd_flush (shell, image); }
static void gimp_image_map_tool_map (GimpImageMapTool *tool) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (GIMP_TOOL (tool)->display->shell); GimpItem *item = GIMP_ITEM (tool->drawable); gint x, y; gint w, h; gint off_x, off_y; GeglRectangle visible; GIMP_IMAGE_MAP_TOOL_GET_CLASS (tool)->map (tool); gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h); gimp_item_offsets (item, &off_x, &off_y); gimp_rectangle_intersect (x, y, w, h, off_x, off_y, gimp_item_width (item), gimp_item_height (item), &visible.x, &visible.y, &visible.width, &visible.height); visible.x -= off_x; visible.y -= off_y; gimp_image_map_apply (tool->image_map, &visible); }
static gboolean gimp_display_shell_update_title_idle (gpointer data) { GimpDisplayShell *shell; GimpDisplayConfig *config; gchar title[MAX_TITLE_BUF]; shell = GIMP_DISPLAY_SHELL (data); config = GIMP_DISPLAY_CONFIG (shell->display->image->gimp->config); shell->title_idle_id = 0; /* format the title */ gimp_display_shell_format_title (shell, title, sizeof (title), config->image_title_format); gdk_window_set_title (GTK_WIDGET (shell)->window, title); /* format the statusbar */ if (strcmp (config->image_title_format, config->image_status_format)) { gimp_display_shell_format_title (shell, title, sizeof (title), config->image_status_format); } gimp_statusbar_replace (GIMP_STATUSBAR (shell->statusbar), "title", "%s", title); return FALSE; }
void image_scale_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GtkWidget *widget; GtkWidget *dialog; return_if_no_display (display, data); return_if_no_widget (widget, data); if (image_scale_unit != GIMP_UNIT_PERCENT) image_scale_unit = GIMP_DISPLAY_SHELL (display->shell)->unit; if (image_scale_interp == -1) image_scale_interp = display->image->gimp->config->interpolation_type; dialog = image_scale_dialog_new (display->image, action_data_get_context (data), widget, image_scale_unit, image_scale_interp, image_scale_callback, display); g_signal_connect_object (display, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); gtk_widget_show (dialog); }
void image_configure_grid_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpDisplayShell *shell; GimpImage *image; return_if_no_display (display, data); shell = GIMP_DISPLAY_SHELL (display->shell); image = display->image; if (! shell->grid_dialog) { shell->grid_dialog = grid_dialog_new (display->image, action_data_get_context (data), display->shell); gtk_window_set_transient_for (GTK_WINDOW (shell->grid_dialog), GTK_WINDOW (display->shell)); gtk_window_set_destroy_with_parent (GTK_WINDOW (shell->grid_dialog), TRUE); g_object_add_weak_pointer (G_OBJECT (shell->grid_dialog), (gpointer) &shell->grid_dialog); } gtk_window_present (GTK_WINDOW (shell->grid_dialog)); }
void gimp_tool_push_status_length (GimpTool *tool, GimpDisplay *display, const gchar *title, GimpOrientationType axis, gdouble value, const gchar *help) { GimpDisplayShell *shell; const gchar *stock_id; g_return_if_fail (GIMP_IS_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); shell = GIMP_DISPLAY_SHELL (display->shell); stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool->tool_info)); gimp_statusbar_push_length (GIMP_STATUSBAR (shell->statusbar), G_OBJECT_TYPE_NAME (tool), stock_id, title, axis, value, help); tool->status_displays = g_list_remove (tool->status_displays, display); tool->status_displays = g_list_prepend (tool->status_displays, display); }
void gimp_tool_push_status_coords (GimpTool *tool, GimpDisplay *display, GimpCursorPrecision precision, const gchar *title, gdouble x, const gchar *separator, gdouble y, const gchar *help) { GimpDisplayShell *shell; const gchar *stock_id; g_return_if_fail (GIMP_IS_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); shell = GIMP_DISPLAY_SHELL (display->shell); stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool->tool_info)); gimp_statusbar_push_coords (GIMP_STATUSBAR (shell->statusbar), G_OBJECT_TYPE_NAME (tool), stock_id, precision, title, x, separator, y, help); tool->status_displays = g_list_remove (tool->status_displays, display); tool->status_displays = g_list_prepend (tool->status_displays, display); }
void gimp_tool_push_status (GimpTool *tool, GimpDisplay *display, const gchar *format, ...) { GimpDisplayShell *shell; const gchar *stock_id; va_list args; g_return_if_fail (GIMP_IS_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); g_return_if_fail (format != NULL); shell = GIMP_DISPLAY_SHELL (display->shell); stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool->tool_info)); va_start (args, format); gimp_statusbar_push_valist (GIMP_STATUSBAR (shell->statusbar), G_OBJECT_TYPE_NAME (tool), stock_id, format, args); va_end (args); tool->status_displays = g_list_remove (tool->status_displays, display); tool->status_displays = g_list_prepend (tool->status_displays, display); }
static void gimp_color_tool_control (GimpTool *tool, GimpToolAction action, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); switch (action) { case GIMP_TOOL_ACTION_PAUSE: break; case GIMP_TOOL_ACTION_RESUME: if (color_tool->sample_point && gimp_display_shell_get_show_sample_points (shell)) gimp_display_shell_draw_sample_point (shell, color_tool->sample_point, TRUE); break; case GIMP_TOOL_ACTION_HALT: if (color_tool->sample_point && gimp_display_shell_get_show_sample_points (shell)) gimp_display_shell_draw_sample_point (shell, color_tool->sample_point, FALSE); break; } GIMP_TOOL_CLASS (parent_class)->control (tool, action, display); }
static gboolean gimp_display_shell_progress_message (GimpProgress *progress, Gimp *gimp, GimpMessageSeverity severity, const gchar *domain, const gchar *message) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); switch (severity) { case GIMP_MESSAGE_ERROR: /* error messages are never handled here */ break; case GIMP_MESSAGE_WARNING: /* warning messages go to the statusbar, if it's visible */ if (! gimp_statusbar_get_visible (statusbar)) break; else return gimp_progress_message (GIMP_PROGRESS (statusbar), gimp, severity, domain, message); case GIMP_MESSAGE_INFO: /* info messages go to the statusbar; * if they are not handled there, they are swallowed */ gimp_progress_message (GIMP_PROGRESS (statusbar), gimp, severity, domain, message); return TRUE; } return FALSE; }
static void gimp_display_flush_whenever (GimpDisplay *display, gboolean now) { if (display->update_areas) { GSList *list; for (list = display->update_areas; list; list = g_slist_next (list)) { GimpArea *area = list->data; if ((area->x1 != area->x2) && (area->y1 != area->y2)) { gimp_display_paint_area (display, area->x1, area->y1, (area->x2 - area->x1), (area->y2 - area->y1)); } } gimp_area_list_free (display->update_areas); display->update_areas = NULL; } gimp_display_shell_flush (GIMP_DISPLAY_SHELL (display->shell), now); }
void gimp_tool_replace_status (GimpTool *tool, GimpDisplay *display, const gchar *format, ...) { GimpDisplayShell *shell; va_list args; g_return_if_fail (GIMP_IS_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); g_return_if_fail (format != NULL); shell = GIMP_DISPLAY_SHELL (display->shell); va_start (args, format); gimp_statusbar_replace_valist (GIMP_STATUSBAR (shell->statusbar), G_OBJECT_TYPE_NAME (tool), format, args); va_end (args); tool->status_displays = g_list_remove (tool->status_displays, display); tool->status_displays = g_list_prepend (tool->status_displays, display); }
static void gimp_display_shell_drop_svg (GtkWidget *widget, gint x, gint y, const guchar *svg_data, gsize svg_data_len, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = shell->display->image; GError *error = NULL; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) return; if (! gimp_vectors_import_buffer (image, (const gchar *) svg_data, svg_data_len, TRUE, TRUE, -1, NULL, &error)) { gimp_message (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } else { gimp_display_shell_dnd_flush (shell, image); } }
static void gimp_display_shell_drop_buffer (GtkWidget *widget, gint drop_x, gint drop_y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = shell->display->image; GimpBuffer *buffer; gint x, y, width, height; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) return; buffer = GIMP_BUFFER (viewable); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); /* FIXME: popup a menu for selecting "Paste Into" */ gimp_edit_paste (image, gimp_image_get_active_drawable (image), buffer, FALSE, x, y, width, height); gimp_display_shell_dnd_flush (shell, image); }
void select_shrink_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GtkWidget *dialog; GtkWidget *button; return_if_no_display (display, data); dialog = gimp_query_size_box (_("Shrink Selection"), display->shell, gimp_standard_help_func, GIMP_HELP_SELECTION_SHRINK, _("Shrink selection by"), select_shrink_pixels, 1, 32767, 0, GIMP_DISPLAY_SHELL (display->shell)->unit, MIN (display->image->xresolution, display->image->yresolution), FALSE, G_OBJECT (display->image), "disconnect", select_shrink_callback, display->image); button = gtk_check_button_new_with_mnemonic (_("_Shrink from image border")); gtk_box_pack_start (GTK_BOX (GIMP_QUERY_BOX_VBOX (dialog)), button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (dialog), "edge-lock-toggle", button); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), ! select_shrink_edge_lock); gtk_widget_show (button); gtk_widget_show (dialog); }
static GdkSegment * gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel, GimpDisplay *display, gint *num_segs) { GimpTool *tool = GIMP_TOOL (region_sel); GimpRegionSelectOptions *options = GIMP_REGION_SELECT_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); GimpDrawable *drawable; GdkSegment *segs; BoundSeg *bsegs; PixelRegion maskPR; drawable = gimp_image_get_active_drawable (display->image); gimp_display_shell_set_override_cursor (shell, GDK_WATCH); if (region_sel->region_mask) g_object_unref (region_sel->region_mask); region_sel->region_mask = GIMP_REGION_SELECT_TOOL_GET_CLASS (region_sel)->get_mask (region_sel, display); if (! region_sel->region_mask) { gimp_display_shell_unset_override_cursor (shell); *num_segs = 0; return NULL; } /* calculate and allocate a new segment array which represents the * boundary of the contiguous region */ pixel_region_init (&maskPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (region_sel->region_mask)), 0, 0, gimp_item_width (GIMP_ITEM (region_sel->region_mask)), gimp_item_height (GIMP_ITEM (region_sel->region_mask)), FALSE); bsegs = boundary_find (&maskPR, BOUNDARY_WITHIN_BOUNDS, 0, 0, gimp_item_width (GIMP_ITEM (region_sel->region_mask)), gimp_item_height (GIMP_ITEM (region_sel->region_mask)), BOUNDARY_HALF_WAY, num_segs); segs = g_new (GdkSegment, *num_segs); gimp_display_shell_transform_segments (shell, bsegs, segs, *num_segs, ! options->sample_merged); g_free (bsegs); gimp_display_shell_unset_override_cursor (shell); return segs; }
static void gimp_display_shell_drop_component (GtkWidget *widget, gint x, gint y, GimpImage *image, GimpChannelType component, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *dest_image = gimp_display_get_image (shell->display); GimpChannel *channel; GimpItem *new_item; const gchar *desc; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! dest_image) { dest_image = gimp_image_new_from_component (image->gimp, image, component); gimp_create_display (dest_image->gimp, dest_image, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (dest_image); return; } channel = gimp_channel_new_from_component (image, component, NULL, NULL); new_item = gimp_item_convert (GIMP_ITEM (channel), dest_image, GIMP_TYPE_LAYER); g_object_unref (channel); if (new_item) { GimpLayer *new_layer = GIMP_LAYER (new_item); gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component, NULL, NULL, &desc, NULL); gimp_object_take_name (GIMP_OBJECT (new_layer), g_strdup_printf (_("%s Channel Copy"), desc)); gimp_image_undo_group_start (dest_image, GIMP_UNDO_GROUP_EDIT_PASTE, _("Drop New Layer")); gimp_display_shell_dnd_position_item (shell, image, new_item); gimp_image_add_layer (dest_image, new_layer, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE); gimp_image_undo_group_end (dest_image); gimp_display_shell_dnd_flush (shell, dest_image); } }
static gboolean gimp_display_shell_progress_is_active (GimpProgress *progress) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); return gimp_progress_is_active (GIMP_PROGRESS (statusbar)); }
static gdouble gimp_display_shell_progress_get_value (GimpProgress *progress) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); return gimp_progress_get_value (GIMP_PROGRESS (statusbar)); }
static void gimp_display_shell_progress_pulse (GimpProgress *progress) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); gimp_progress_pulse (GIMP_PROGRESS (statusbar)); }
static void gimp_display_shell_drop_pixbuf (GtkWidget *widget, gint x, gint y, GdkPixbuf *pixbuf, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = gimp_display_get_image (shell->display); GimpLayer *new_layer; gboolean has_alpha = FALSE; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { image = gimp_image_new_from_pixbuf (shell->display->gimp, pixbuf, _("Dropped Buffer")); gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (image); return; } if (gdk_pixbuf_get_n_channels (pixbuf) == 2 || gdk_pixbuf_get_n_channels (pixbuf) == 4) { has_alpha = TRUE; } new_layer = gimp_layer_new_from_pixbuf (pixbuf, image, gimp_image_get_layer_format (image, has_alpha), _("Dropped Buffer"), GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); if (new_layer) { GimpItem *new_item = GIMP_ITEM (new_layer); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, _("Drop New Layer")); gimp_display_shell_dnd_position_item (shell, image, new_item); gimp_image_add_layer (image, new_layer, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE); gimp_image_undo_group_end (image); gimp_display_shell_dnd_flush (shell, image); } }
static void gimp_display_shell_progress_set_text (GimpProgress *progress, const gchar *message) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); gimp_progress_set_text (GIMP_PROGRESS (statusbar), message); }
static void gimp_display_shell_progress_set_value (GimpProgress *progress, gdouble percentage) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); gimp_progress_set_value (GIMP_PROGRESS (statusbar), percentage); }
static void gimp_display_shell_drop_drawable (GtkWidget *widget, gint x, gint y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = gimp_display_get_image (shell->display); GType new_type; GimpItem *new_item; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { image = gimp_image_new_from_drawable (shell->display->gimp, GIMP_DRAWABLE (viewable)); gimp_create_display (shell->display->gimp, image, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (image); return; } if (GIMP_IS_LAYER (viewable)) new_type = G_TYPE_FROM_INSTANCE (viewable); else new_type = GIMP_TYPE_LAYER; new_item = gimp_item_convert (GIMP_ITEM (viewable), image, new_type); if (new_item) { GimpLayer *new_layer = GIMP_LAYER (new_item); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, _("Drop New Layer")); gimp_display_shell_dnd_position_item (shell, image, new_item); gimp_item_set_visible (new_item, TRUE, FALSE); gimp_item_set_linked (new_item, FALSE, FALSE); gimp_image_add_layer (image, new_layer, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE); gimp_image_undo_group_end (image); gimp_display_shell_dnd_flush (shell, image); } }
static GimpProgress * gimp_display_shell_progress_start (GimpProgress *progress, const gchar *message, gboolean cancelable) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (progress); GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell); return gimp_progress_start (GIMP_PROGRESS (statusbar), message, cancelable); }
static void gimp_align_tool_oper_update (GimpTool *tool, GimpCoords *coords, GdkModifierType state, gboolean proximity, GimpDisplay *display) { GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); gint snap_distance; snap_distance = GIMP_DISPLAY_CONFIG (display->image->gimp->config)->snap_distance; if (gimp_draw_tool_on_vectors (GIMP_DRAW_TOOL (tool), display, coords, snap_distance, snap_distance, NULL, NULL, NULL, NULL, NULL, NULL)) { if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects) align_tool->function = ALIGN_TOOL_ADD_PATH; else align_tool->function = ALIGN_TOOL_PICK_PATH; } else if (gimp_display_shell_get_show_guides (shell) && (NULL != gimp_image_find_guide (display->image, coords->x, coords->y, FUNSCALEX (shell, snap_distance), FUNSCALEY (shell, snap_distance)))) { if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects) align_tool->function = ALIGN_TOOL_ADD_GUIDE; else align_tool->function = ALIGN_TOOL_PICK_GUIDE; } else { GimpLayer *layer = select_layer_by_coords (display->image, coords->x, coords->y); if (layer) { if ((state & GDK_SHIFT_MASK) && align_tool->selected_objects) align_tool->function = ALIGN_TOOL_ADD_LAYER; else align_tool->function = ALIGN_TOOL_PICK_LAYER; } else { align_tool->function = ALIGN_TOOL_IDLE; } } gimp_align_tool_status_update (tool, display, state, proximity); }
static gboolean gimp_display_shell_idle_update_icon (gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); shell->icon_idle_id = 0; gimp_display_shell_update_icon (shell); return FALSE; }
static void gimp_display_shell_drop_color (GtkWidget *widget, gint x, gint y, const GimpRGB *color, gpointer data) { GIMP_LOG (DND, NULL); gimp_display_shell_dnd_bucket_fill (GIMP_DISPLAY_SHELL (data), GIMP_FG_BUCKET_FILL, color, NULL); }
void gimp_tool_set_cursor (GimpTool *tool, GimpDisplay *display, GimpCursorType cursor, GimpToolCursorType tool_cursor, GimpCursorModifier modifier) { g_return_if_fail (GIMP_IS_TOOL (tool)); g_return_if_fail (GIMP_IS_DISPLAY (display)); gimp_display_shell_set_cursor (GIMP_DISPLAY_SHELL (display->shell), cursor, tool_cursor, modifier); }