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);
}
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);
}
/* -----------------------
* p_tri_map_preprocessing
* -----------------------
* prepare the tri mask for processing
* - have bpp == 1
* - have same size and offset as the input drawable (that is a layer)
* - pixel values >= 240 are set to value 240 (MATTING_USER_FOREGROUND)
* - in case the input layer already has an alpha channel
* all fully transparent (alpha == 0) pixels are also set 0 (MATTING_USER_BACKGROUND)
* in the tri map to keep pixels fully transparent. (such pixels typicall do not
* have a useful color information in the RGB channels)
*
*
* in case the user provided the tri map as layer or channel that is NOT the layermask of the input layer
* we create a new dummy layer with same size and offset as the input layer
* and add a layermask to this dummy layer.
* The layermask of the dummy layer is then filled with the intersecting grayscale copy
* of the user-provided triMap drawable and will be used as tri map in the alpha matting processing.
*
* returns the dawable Id of the relevant TRI MAP that fulfills the conditons listed above.
*/
static gint32
p_tri_map_preprocessing (GimpDrawable *drawable, GapFgExtractValues *fgValPtr, gint32 *dummyLayerId)
{
gint32 prepocessedTriMapLayerId;
gint32 inputLayerMaskId;
gint32 imageId;
*dummyLayerId = -1;
imageId = gimp_drawable_get_image(drawable->drawable_id);
inputLayerMaskId = gimp_layer_get_mask(drawable->drawable_id);
if (fgValPtr->tri_map_drawable_id == inputLayerMaskId)
{
prepocessedTriMapLayerId = inputLayerMaskId;
}
else
{
gint offset_x;
gint offset_y;
gint32 dummyLayerMaskId;
gint32 l_fsel_layer_id;
*dummyLayerId = gimp_layer_new(imageId
, "DUMMY"
, drawable->width
, drawable->height
, GIMP_RGBA_IMAGE
, 100.0 /* full opacity */
, GIMP_NORMAL_MODE /* normal mode */
);
/* get offsets of the input drawable (layer) within the image */
gimp_drawable_offsets (drawable->drawable_id, &offset_x, &offset_y);
/* add dummy layer (of same size at same offsets) to the same image */
gimp_image_add_layer(imageId, *dummyLayerId, -1 /* stackposition */ );
gimp_layer_set_offsets(*dummyLayerId, offset_x, offset_y);
/* create a new layermask (black is full transparent */
dummyLayerMaskId = gimp_layer_create_mask(*dummyLayerId, GIMP_ADD_BLACK_MASK);
gimp_layer_add_mask(*dummyLayerId, dummyLayerMaskId);
gimp_edit_copy(fgValPtr->tri_map_drawable_id);
l_fsel_layer_id = gimp_edit_paste(dummyLayerMaskId, FALSE);
gimp_floating_sel_anchor(l_fsel_layer_id);
prepocessedTriMapLayerId = dummyLayerMaskId;
}
gap_fg_rgn_tri_map_normalize(drawable, prepocessedTriMapLayerId);
return(prepocessedTriMapLayerId);
} /* end p_tri_map_preprocessing */
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."));
}
}
}
static GimpValueArray *
edit_named_paste_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
GimpDrawable *drawable;
const gchar *buffer_name;
gboolean paste_into;
GimpLayer *floating_sel = NULL;
drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp);
buffer_name = g_value_get_string (gimp_value_array_index (args, 1));
paste_into = g_value_get_boolean (gimp_value_array_index (args, 2));
if (success)
{
GimpBuffer *buffer = gimp_pdb_get_buffer (gimp, buffer_name, error);
if (buffer &&
gimp_pdb_item_is_attached (GIMP_ITEM (drawable), NULL,
GIMP_PDB_ITEM_CONTENT, error) &&
gimp_pdb_item_is_not_group (GIMP_ITEM (drawable), error))
{
floating_sel = gimp_edit_paste (gimp_item_get_image (GIMP_ITEM (drawable)),
drawable, GIMP_OBJECT (buffer),
paste_into ?
GIMP_PASTE_TYPE_FLOATING_INTO :
GIMP_PASTE_TYPE_FLOATING,
-1, -1, -1, -1);
if (! floating_sel)
success = FALSE;
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
gimp_value_set_layer (gimp_value_array_index (return_vals, 1), floating_sel);
return return_vals;
}
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_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);
}
