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);
}