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 void gimp_cage_tool_image_map_update (GimpCageTool *ct) { GimpTool *tool = GIMP_TOOL (ct); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GimpItem *item = GIMP_ITEM (tool->drawable); gint x, y; gint w, h; gint off_x, off_y; GeglRectangle visible; gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h); gimp_item_get_offset (item, &off_x, &off_y); gimp_rectangle_intersect (x, y, w, h, off_x, off_y, gimp_item_get_width (item), gimp_item_get_height (item), &visible.x, &visible.y, &visible.width, &visible.height); visible.x -= off_x; visible.y -= off_y; gimp_image_map_apply (ct->image_map, &visible); }
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); }
/* * Position the dropped item in the middle of the viewport. */ static void gimp_display_shell_dnd_position_item (GimpDisplayShell *shell, GimpImage *image, GimpItem *item) { gint item_width = gimp_item_get_width (item); gint item_height = gimp_item_get_height (item); gint off_x, off_y; if (item_width >= gimp_image_get_width (image) && item_height >= gimp_image_get_height (image)) { off_x = (gimp_image_get_width (image) - item_width) / 2; off_y = (gimp_image_get_height (image) - item_height) / 2; } else { gint x, y; gint width, height; gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); off_x = x + (width - item_width) / 2; off_y = y + (height - item_height) / 2; } gimp_item_translate (item, off_x - gimp_item_get_offset_x (item), off_y - gimp_item_get_offset_y (item), FALSE); }
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 GimpProgress * gimp_tool_progress_start (GimpProgress *progress, const gchar *message, gboolean cancelable) { GimpTool *tool = GIMP_TOOL (progress); GimpDisplayShell *shell; gint x, y, w, h; g_return_val_if_fail (GIMP_IS_DISPLAY (tool->display), NULL); g_return_val_if_fail (tool->progress == NULL, NULL); shell = gimp_display_get_shell (tool->display); gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h); tool->progress = gimp_canvas_progress_new (shell, GIMP_HANDLE_ANCHOR_CENTER, x + w / 2, y + h / 2); gimp_display_shell_add_item (shell, tool->progress); g_object_unref (tool->progress); gimp_progress_start (GIMP_PROGRESS (tool->progress), message, FALSE); gimp_widget_flush_expose (shell->canvas); tool->progress_display = tool->display; return progress; }
static void edit_paste (GimpDisplay *display, gboolean paste_into) { GimpImage *image = gimp_display_get_image (display); gchar *svg; gsize svg_size; svg = gimp_clipboard_get_svg (display->gimp, &svg_size); if (svg) { if (gimp_vectors_import_buffer (image, svg, svg_size, TRUE, FALSE, GIMP_IMAGE_ACTIVE_PARENT, -1, NULL, NULL)) { gimp_image_flush (image); } g_free (svg); } else { GimpBuffer *buffer; buffer = gimp_clipboard_get_buffer (display->gimp); if (buffer) { GimpDisplayShell *shell = gimp_display_get_shell (display); gint x, y; gint width, height; gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); if (gimp_edit_paste (image, gimp_image_get_active_drawable (image), buffer, paste_into, x, y, width, height)) { gimp_image_flush (image); } g_object_unref (buffer); } else { gimp_message_literal (display->gimp, G_OBJECT (display), GIMP_MESSAGE_WARNING, _("There is no image data in the clipboard to paste.")); } } }
/* * Position the dropped item in the middle of the viewport. */ static void gimp_display_shell_dnd_position_item (GimpDisplayShell *shell, GimpItem *item) { gint x, y; gint width, height; gint off_x, off_y; gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); gimp_item_offsets (item, &off_x, &off_y); off_x = x + (width - gimp_item_width (item)) / 2 - off_x; off_y = y + (height - gimp_item_height (item)) / 2 - off_y; gimp_item_translate (item, off_x, off_y, FALSE); }
static void buffers_paste (GimpBufferView *view, gboolean paste_into) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view); GimpContainer *container; GimpContext *context; GimpBuffer *buffer; container = gimp_container_view_get_container (editor->view); context = gimp_container_view_get_context (editor->view); buffer = gimp_context_get_buffer (context); if (buffer && gimp_container_have (container, GIMP_OBJECT (buffer))) { GimpDisplay *display = gimp_context_get_display (context); GimpImage *image = NULL; gint x = -1; gint y = -1; gint width = -1; gint height = -1; if (display) { GimpDisplayShell *shell = gimp_display_get_shell (display); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); image = gimp_display_get_image (display); } else { image = gimp_context_get_image (context); } if (image) { gimp_edit_paste (image, gimp_image_get_active_drawable (image), buffer, paste_into, x, y, width, height); gimp_image_flush (image); } } }
static void gimp_color_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); if (! color_tool->enabled) return; if (color_tool->moving_sample_point) { gint tx, ty; gboolean delete_point = FALSE; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty); if (tx < 0 || tx > shell->disp_width || ty < 0 || ty > shell->disp_height) { color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; delete_point = TRUE; } else { gint x, y, width, height; color_tool->sample_point_x = floor (coords->x); color_tool->sample_point_y = floor (coords->y); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); if ((color_tool->sample_point_x < x || color_tool->sample_point_x > (x + width - 1) || color_tool->sample_point_y < y || color_tool->sample_point_y > (y + height - 1))) { delete_point = TRUE; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_point) { gimp_tool_push_status (tool, display, color_tool->sample_point ? _("Remove Sample Point") : _("Cancel Sample Point")); } else { gimp_tool_push_status_coords (tool, display, gimp_tool_control_get_precision (tool->control), color_tool->sample_point ? _("Move Sample Point: ") : _("Add Sample Point: "), color_tool->sample_point_x, ", ", color_tool->sample_point_y, NULL); } } else { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); color_tool->center_x = coords->x; color_tool->center_y = coords->y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_UPDATE, coords->x, coords->y); } }
static void gimp_display_shell_drop_uri_list (GtkWidget *widget, gint x, gint y, GList *uri_list, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image; GimpContext *context; GList *list; gboolean open_as_layers; /* If the app is already being torn down, shell->display might be NULL here. * Play it safe. */ if (! shell->display) { return; } image = shell->display->image; context = gimp_get_user_context (shell->display->gimp); GIMP_LOG (DND, NULL); open_as_layers = (shell->display->image != NULL); for (list = uri_list; list; list = g_list_next (list)) { const gchar *uri = list->data; GimpPDBStatusType status; GError *error = NULL; gboolean warn = FALSE; if (! shell->display) { /* It seems as if GIMP is being torn down for quitting. Bail out. */ return; } if (open_as_layers) { GList *new_layers; new_layers = file_open_layers (shell->display->gimp, context, GIMP_PROGRESS (shell->display), image, FALSE, uri, GIMP_RUN_INTERACTIVE, NULL, &status, &error); if (new_layers) { gint x, y; gint width, height; gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); gimp_image_add_layers (image, new_layers, -1, x, y, width, height, _("Drop layers")); g_list_free (new_layers); } else if (status != GIMP_PDB_CANCEL) { warn = TRUE; } } else if (shell->display->image) { /* open any subsequent images in a new display */ GimpImage *new_image; new_image = file_open_with_display (shell->display->gimp, context, NULL, uri, FALSE, &status, &error); if (! new_image && status != GIMP_PDB_CANCEL) warn = TRUE; } else { /* open the first image in the empty display */ image = file_open_with_display (shell->display->gimp, context, GIMP_PROGRESS (shell->display), uri, FALSE, &status, &error); if (! image && status != GIMP_PDB_CANCEL) warn = TRUE; } /* Something above might have run a few rounds of the main loop. Check * that shell->display is still there, otherwise ignore this as the app * is being torn down for quitting. */ if (warn && shell->display) { gchar *filename = file_utils_uri_display_name (uri); gimp_message (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Opening '%s' failed:\n\n%s"), filename, error->message); g_clear_error (&error); g_free (filename); } } if (image) gimp_display_shell_dnd_flush (shell, image); }
static void gimp_move_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); if (move->moving_guide) { gint tx, ty; gboolean delete_guide = FALSE; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty); if (tx < 0 || tx >= shell->disp_width || ty < 0 || ty >= shell->disp_height) { move->guide_position = GUIDE_POSITION_INVALID; delete_guide = TRUE; } else { gint x, y, width, height; if (move->guide_orientation == GIMP_ORIENTATION_HORIZONTAL) move->guide_position = RINT (coords->y); else move->guide_position = RINT (coords->x); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); switch (move->guide_orientation) { case GIMP_ORIENTATION_HORIZONTAL: if ((move->guide_position < y) || (move->guide_position > (y + height))) delete_guide = TRUE; break; case GIMP_ORIENTATION_VERTICAL: if ((move->guide_position < x) || (move->guide_position > (x + width))) delete_guide = TRUE; break; default: break; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_guide) { gimp_tool_push_status (tool, display, move->guide ? _("Remove Guide") : _("Cancel Guide")); } else { gimp_tool_push_status_length (tool, display, move->guide ? _("Move Guide: ") : _("Add Guide: "), SWAP_ORIENT (move->guide_orientation), move->guide_position, NULL); } } }
static void gimp_move_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpMoveTool *move = GIMP_MOVE_TOOL (tool); GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); if (gimp_tool_control_is_active (tool->control)) gimp_tool_control_halt (tool->control); if (move->moving_guide) { gboolean delete_guide = FALSE; gint x, y, width, height; gimp_tool_pop_status (tool, display); gimp_tool_control_set_scroll_lock (tool->control, FALSE); gimp_tool_control_set_precision (tool->control, GIMP_CURSOR_PRECISION_PIXEL_CENTER); gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { move->moving_guide = FALSE; move->guide_position = GUIDE_POSITION_INVALID; move->guide_orientation = GIMP_ORIENTATION_UNKNOWN; gimp_display_shell_selection_resume (shell); return; } gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); switch (move->guide_orientation) { case GIMP_ORIENTATION_HORIZONTAL: if ((move->guide_position < y) || (move->guide_position > (y + height))) delete_guide = TRUE; break; case GIMP_ORIENTATION_VERTICAL: if ((move->guide_position < x) || (move->guide_position > (x + width))) delete_guide = TRUE; break; default: break; } if (delete_guide) { if (move->guide) { gimp_image_remove_guide (image, move->guide, TRUE); move->guide = NULL; } } else { if (move->guide) { gimp_image_move_guide (image, move->guide, move->guide_position, TRUE); } else { switch (move->guide_orientation) { case GIMP_ORIENTATION_HORIZONTAL: move->guide = gimp_image_add_hguide (image, move->guide_position, TRUE); break; case GIMP_ORIENTATION_VERTICAL: move->guide = gimp_image_add_vguide (image, move->guide_position, TRUE); break; default: g_assert_not_reached (); } } } gimp_display_shell_selection_resume (shell); gimp_image_flush (image); move->moving_guide = FALSE; move->guide_position = GUIDE_POSITION_INVALID; move->guide_orientation = GIMP_ORIENTATION_UNKNOWN; if (move->guide) gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); } else { gboolean flush = FALSE; if (! config->move_tool_changes_active || (release_type == GIMP_BUTTON_RELEASE_CANCEL)) { if (move->old_active_layer) { gimp_image_set_active_layer (image, move->old_active_layer); move->old_active_layer = NULL; flush = TRUE; } if (move->old_active_vectors) { gimp_image_set_active_vectors (image, move->old_active_vectors); move->old_active_vectors = NULL; flush = TRUE; } } if (release_type != GIMP_BUTTON_RELEASE_CANCEL) { if (move->floating_layer) { floating_sel_anchor (move->floating_layer); flush = TRUE; } } if (flush) gimp_image_flush (image); } }
static void gimp_seamless_clone_tool_filter_update (GimpSeamlessCloneTool *sc) { GimpTool *tool = GIMP_TOOL (sc); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GimpItem *item = GIMP_ITEM (tool->drawable); gint x, y; gint w, h; gint off_x, off_y; GeglRectangle visible; GeglOperation *op = NULL; GimpProgress *progress; GeglNode *output; GeglProcessor *processor; gdouble value; progress = gimp_progress_start (GIMP_PROGRESS (sc), FALSE, _("Cloning the foreground object")); /* Find out at which x,y is the top left corner of the currently * displayed part */ gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h); /* Find out where is our drawable positioned */ gimp_item_get_offset (item, &off_x, &off_y); /* Create a rectangle from the intersection of the currently displayed * part with the drawable */ gimp_rectangle_intersect (x, y, w, h, off_x, off_y, gimp_item_get_width (item), gimp_item_get_height (item), &visible.x, &visible.y, &visible.width, &visible.height); /* Since the filter_apply function receives a rectangle describing * where it should update the preview, and since that rectangle should * be relative to the drawable's location, we now offset back by the * drawable's offsetts. */ visible.x -= off_x; visible.y -= off_y; g_object_get (sc->sc_node, "gegl-operation", &op, NULL); /* If any cache of the visible area was present, clear it! * We need to clear the cache in the sc_node, since that is * where the previous paste was located */ gegl_operation_invalidate (op, &visible, TRUE); g_object_unref (op); /* Now update the image map and show this area */ gimp_drawable_filter_apply (sc->filter, NULL); /* Show update progress. */ output = gegl_node_get_output_proxy (sc->render_node, "output"); processor = gegl_node_new_processor (output, NULL); while (gegl_processor_work (processor, &value)) { if (progress) gimp_progress_set_value (progress, value); } if (progress) gimp_progress_end (progress); g_object_unref (processor); }
static void gimp_color_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); /* Chain up to halt the tool */ GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, release_type, display); if (! color_tool->enabled) return; if (color_tool->moving_sample_point) { gint x, y, width, height; gimp_tool_pop_status (tool, display); gimp_tool_control_set_scroll_lock (tool->control, FALSE); gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); if (release_type == GIMP_BUTTON_RELEASE_CANCEL) { color_tool->moving_sample_point = FALSE; color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; gimp_display_shell_selection_resume (shell); return; } gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); if ((color_tool->sample_point_x < x || color_tool->sample_point_x > (x + width - 1) || color_tool->sample_point_y < y || color_tool->sample_point_y > (y + height - 1))) { if (color_tool->sample_point) { gimp_image_remove_sample_point (image, color_tool->sample_point, TRUE); color_tool->sample_point = NULL; } } else { if (color_tool->sample_point) { gimp_image_move_sample_point (image, color_tool->sample_point, color_tool->sample_point_x, color_tool->sample_point_y, TRUE); } else { color_tool->sample_point = gimp_image_add_sample_point_at_pos (image, color_tool->sample_point_x, color_tool->sample_point_y, TRUE); } } gimp_display_shell_selection_resume (shell); gimp_image_flush (image); color_tool->moving_sample_point = FALSE; color_tool->sample_point_x = SAMPLE_POINT_POSITION_INVALID; color_tool->sample_point_y = SAMPLE_POINT_POSITION_INVALID; if (color_tool->sample_point) gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display); } else { gimp_draw_tool_stop (GIMP_DRAW_TOOL (tool)); } }
static void gimp_color_tool_motion (GimpTool *tool, GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpColorTool *color_tool = GIMP_COLOR_TOOL (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); if (! color_tool->enabled) return; if (color_tool->moving_sample_point) { gint tx, ty; gboolean delete_point = FALSE; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_display_shell_transform_xy (shell, coords->x, coords->y, &tx, &ty, FALSE); if (tx < 0 || tx > shell->disp_width || ty < 0 || ty > shell->disp_height) { color_tool->sample_point_x = -1; color_tool->sample_point_y = -1; delete_point = TRUE; } else { gint x, y, width, height; color_tool->sample_point_x = floor (coords->x); color_tool->sample_point_y = floor (coords->y); gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); if ((color_tool->sample_point_x < x || color_tool->sample_point_x > (x + width - 1) || color_tool->sample_point_y < y || color_tool->sample_point_y > (y + height - 1))) { delete_point = TRUE; } } gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_tool_pop_status (tool, display); if (delete_point) { gimp_tool_push_status (tool, display, color_tool->sample_point ? _("Remove Sample Point") : _("Cancel Sample Point")); } else { gimp_tool_push_status_coords (tool, display, color_tool->sample_point ? _("Move Sample Point: ") : _("Add Sample Point: "), color_tool->sample_point_x, ", ", color_tool->sample_point_y, NULL); } } else { gint off_x, off_y; gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); gimp_item_offsets (GIMP_ITEM (tool->drawable), &off_x, &off_y); color_tool->center_x = coords->x - off_x; color_tool->center_y = coords->y - off_y; gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); gimp_color_tool_pick (color_tool, GIMP_COLOR_PICK_STATE_UPDATE, coords->x, coords->y); } }
static void gimp_image_map_tool_options_notify (GimpTool *tool, GimpToolOptions *options, const GParamSpec *pspec) { GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool); GimpImageMapOptions *im_options = GIMP_IMAGE_MAP_OPTIONS (options); if (! strcmp (pspec->name, "preview") && im_tool->image_map) { if (im_options->preview) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_apply (im_tool->image_map, NULL); gimp_tool_control_pop_preserve (tool->control); if (im_options->preview_split) gimp_image_map_tool_add_guide (im_tool); } else { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_image_map_abort (im_tool->image_map); gimp_tool_control_pop_preserve (tool->control); if (im_options->preview_split) gimp_image_map_tool_remove_guide (im_tool); } } else if (! strcmp (pspec->name, "preview-split") && im_tool->image_map) { if (im_options->preview_split) { GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GimpItem *item = GIMP_ITEM (im_tool->drawable); gint x, y, width, height; gimp_display_shell_untransform_viewport (shell, &x, &y, &width, &height); if (gimp_rectangle_intersect (gimp_item_get_offset_x (item), gimp_item_get_offset_y (item), gimp_item_get_width (item), gimp_item_get_height (item), x, y, width, height, &x, &y, &width, &height)) { gdouble position; if (im_options->preview_alignment == GIMP_ALIGN_LEFT || im_options->preview_alignment == GIMP_ALIGN_RIGHT) { position = ((gdouble) ((x + width / 2) - gimp_item_get_offset_x (item)) / (gdouble) gimp_item_get_width (item)); } else { position = ((gdouble) ((y + height / 2) - gimp_item_get_offset_y (item)) / (gdouble) gimp_item_get_height (item)); } g_object_set (options, "preview-position", CLAMP (position, 0.0, 1.0), NULL); } } gimp_image_map_set_preview (im_tool->image_map, im_options->preview_split, im_options->preview_alignment, im_options->preview_position); if (im_options->preview_split) gimp_image_map_tool_add_guide (im_tool); else gimp_image_map_tool_remove_guide (im_tool); } else if (! strcmp (pspec->name, "preview-alignment") && im_tool->image_map) { gimp_image_map_set_preview (im_tool->image_map, im_options->preview_split, im_options->preview_alignment, im_options->preview_position); if (im_options->preview_split) gimp_image_map_tool_move_guide (im_tool); } else if (! strcmp (pspec->name, "preview-position") && im_tool->image_map) { gimp_image_map_set_preview (im_tool->image_map, im_options->preview_split, im_options->preview_alignment, im_options->preview_position); if (im_options->preview_split) gimp_image_map_tool_move_guide (im_tool); } else if (! strcmp (pspec->name, "region") && im_tool->image_map) { gimp_image_map_set_region (im_tool->image_map, im_options->region); gimp_image_map_tool_preview (im_tool); } }
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; GimpPasteType paste_type; 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 (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (image); return; } paste_type = GIMP_PASTE_TYPE_FLOATING; 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_INFO, _("Pasted as new layer because the " "target is a layer group.")); paste_type = GIMP_PASTE_TYPE_NEW_LAYER; } else if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { gimp_message_literal (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, _("Pasted as new layer because the " "target's pixels are locked.")); paste_type = GIMP_PASTE_TYPE_NEW_LAYER; } } 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, GIMP_OBJECT (buffer), paste_type, x, y, width, height); gimp_display_shell_dnd_flush (shell, image); }