gboolean
floating_sel_to_layer (GimpLayer *layer,
GError **error)
{
GimpItem *item;
GimpImage *image;
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
g_return_val_if_fail (gimp_layer_is_floating_sel (layer), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
item = GIMP_ITEM (layer);
image = gimp_item_get_image (item);
/* Check if the floating layer belongs to a channel */
if (GIMP_IS_CHANNEL (gimp_layer_get_floating_sel_drawable (layer)))
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Cannot create a new layer from the floating "
"selection because it belongs to a layer mask "
"or channel."));
return FALSE;
}
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_TO_LAYER,
C_("undo-type", "Floating Selection to Layer"));
gimp_image_undo_push_fs_to_layer (image, NULL, layer);
gimp_drawable_detach_floating_sel (gimp_layer_get_floating_sel_drawable (layer));
gimp_layer_set_floating_sel_drawable (layer, NULL);
gimp_item_set_visible (item, TRUE, TRUE);
gimp_layer_set_lock_alpha (layer, FALSE, TRUE);
gimp_image_undo_group_end (image);
/* When the floating selection is converted to/from a normal layer
* it does something resembling a name change, so emit the
* "name-changed" signal
*/
gimp_object_name_changed (GIMP_OBJECT (layer));
gimp_drawable_update (GIMP_DRAWABLE (layer),
0, 0,
gimp_item_get_width (item),
gimp_item_get_height (item));
return TRUE;
}
void
floating_sel_activate_drawable (GimpLayer *layer)
{
GimpImage *image;
GimpDrawable *drawable;
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
image = gimp_item_get_image (GIMP_ITEM (layer));
drawable = gimp_layer_get_floating_sel_drawable (layer);
/* set the underlying drawable to active */
if (GIMP_IS_LAYER_MASK (drawable))
{
GimpLayerMask *mask = GIMP_LAYER_MASK (drawable);
gimp_image_set_active_layer (image, gimp_layer_mask_get_layer (mask));
}
else if (GIMP_IS_CHANNEL (drawable))
{
gimp_image_set_active_channel (image, GIMP_CHANNEL (drawable));
}
else
{
gimp_image_set_active_layer (image, GIMP_LAYER (drawable));
}
}
static void
gimp_floating_sel_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpFloatingSelUndo *floating_sel_undo = GIMP_FLOATING_SEL_UNDO (undo);
GimpLayer *floating_layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_FS_TO_LAYER:
if (undo_mode == GIMP_UNDO_MODE_UNDO)
{
/* Update the preview for the floating sel */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (floating_layer));
gimp_layer_set_floating_sel_drawable (floating_layer,
floating_sel_undo->drawable);
gimp_image_set_active_layer (undo->image, floating_layer);
gimp_drawable_attach_floating_sel (gimp_layer_get_floating_sel_drawable (floating_layer),
floating_layer);
}
else
{
gimp_drawable_detach_floating_sel (gimp_layer_get_floating_sel_drawable (floating_layer));
gimp_layer_set_floating_sel_drawable (floating_layer, NULL);
}
/* When the floating selection is converted to/from a normal
* layer it does something resembling a name change, so emit the
* "name-changed" signal
*/
gimp_object_name_changed (GIMP_OBJECT (floating_layer));
gimp_drawable_update (GIMP_DRAWABLE (floating_layer),
0, 0,
gimp_item_get_width (GIMP_ITEM (floating_layer)),
gimp_item_get_height (GIMP_ITEM (floating_layer)));
break;
default:
g_assert_not_reached ();
}
}
void
floating_sel_anchor (GimpLayer *layer)
{
GimpImage *image;
GimpDrawable *drawable;
GimpFilter *filter = NULL;
gint off_x, off_y;
gint dr_off_x, dr_off_y;
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
/* Don't let gimp_image_remove_layer free the layer while we still need it */
g_object_ref (layer);
image = gimp_item_get_image (GIMP_ITEM (layer));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR,
C_("undo-type", "Anchor Floating Selection"));
drawable = gimp_layer_get_floating_sel_drawable (layer);
gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y);
gimp_item_get_offset (GIMP_ITEM (drawable), &dr_off_x, &dr_off_y);
if (gimp_item_get_visible (GIMP_ITEM (layer)) &&
gimp_rectangle_intersect (off_x, off_y,
gimp_item_get_width (GIMP_ITEM (layer)),
gimp_item_get_height (GIMP_ITEM (layer)),
dr_off_x, dr_off_y,
gimp_item_get_width (GIMP_ITEM (drawable)),
gimp_item_get_height (GIMP_ITEM (drawable)),
NULL, NULL, NULL, NULL))
{
filter = gimp_drawable_get_floating_sel_filter (drawable);
g_object_ref (filter);
}
/* first remove the filter, then merge it, or we will get warnings
* about already connected nodes
*/
gimp_image_remove_layer (image, layer, TRUE, NULL);
if (filter)
{
gimp_drawable_merge_filter (drawable, filter, NULL, NULL);
g_object_unref (filter);
}
gimp_image_undo_group_end (image);
/* invalidate the boundaries */
gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image)));
g_object_unref (layer);
}
void
floating_sel_invalidate (GimpLayer *layer)
{
g_return_if_fail (GIMP_IS_LAYER (layer));
g_return_if_fail (gimp_layer_is_floating_sel (layer));
/* Invalidate the attached-to drawable's preview */
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimp_layer_get_floating_sel_drawable (layer)));
/* Invalidate the boundary */
layer->fs.boundary_known = FALSE;
}
static void
gimp_floating_sel_undo_constructed (GObject *object)
{
GimpFloatingSelUndo *floating_sel_undo = GIMP_FLOATING_SEL_UNDO (object);
GimpLayer *layer;
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item));
layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item);
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_FS_TO_LAYER:
floating_sel_undo->drawable = gimp_layer_get_floating_sel_drawable (layer);
break;
default:
g_assert_not_reached ();
}
}
static void
gimp_image_duplicate_floating_sel (GimpImage *image,
GimpImage *new_image)
{
GimpLayer *floating_sel;
GimpDrawable *floating_sel_drawable;
GList *floating_sel_path;
GimpItemStack *new_item_stack;
GimpLayer *new_floating_sel;
GimpDrawable *new_floating_sel_drawable;
floating_sel = gimp_image_get_floating_selection (image);
if (! floating_sel)
return;
floating_sel_drawable = gimp_layer_get_floating_sel_drawable (floating_sel);
if (GIMP_IS_LAYER_MASK (floating_sel_drawable))
{
GimpLayer *layer;
layer = gimp_layer_mask_get_layer (GIMP_LAYER_MASK (floating_sel_drawable));
floating_sel_path = gimp_item_get_path (GIMP_ITEM (layer));
new_item_stack = GIMP_ITEM_STACK (gimp_image_get_layers (new_image));
}
else
{
floating_sel_path = gimp_item_get_path (GIMP_ITEM (floating_sel_drawable));
if (GIMP_IS_LAYER (floating_sel_drawable))
new_item_stack = GIMP_ITEM_STACK (gimp_image_get_layers (new_image));
else
new_item_stack = GIMP_ITEM_STACK (gimp_image_get_channels (new_image));
}
/* adjust path[0] for the floating layer missing in new_image */
floating_sel_path->data =
GUINT_TO_POINTER (GPOINTER_TO_UINT (floating_sel_path->data) - 1);
if (GIMP_IS_LAYER (floating_sel_drawable))
{
new_floating_sel =
GIMP_LAYER (gimp_image_duplicate_item (GIMP_ITEM (floating_sel),
new_image));
}
else
{
/* can't use gimp_item_convert() for floating selections of channels
* or layer masks because they maybe don't have a normal layer's type
*/
new_floating_sel =
GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (floating_sel),
G_TYPE_FROM_INSTANCE (floating_sel)));
gimp_item_set_image (GIMP_ITEM (new_floating_sel), new_image);
gimp_object_set_name (GIMP_OBJECT (new_floating_sel),
gimp_object_get_name (floating_sel));
}
/* Make sure the copied layer doesn't say: "<old layer> copy" */
gimp_object_set_name (GIMP_OBJECT (new_floating_sel),
gimp_object_get_name (floating_sel));
new_floating_sel_drawable =
GIMP_DRAWABLE (gimp_item_stack_get_item_by_path (new_item_stack,
floating_sel_path));
if (GIMP_IS_LAYER_MASK (floating_sel_drawable))
new_floating_sel_drawable =
GIMP_DRAWABLE (gimp_layer_get_mask (GIMP_LAYER (new_floating_sel_drawable)));
floating_sel_attach (new_floating_sel, new_floating_sel_drawable);
g_list_free (floating_sel_path);
}
GimpLayer *
gimp_image_merge_visible_layers (GimpImage *image,
GimpContext *context,
GimpMergeType merge_type,
gboolean merge_active_group,
gboolean discard_invisible)
{
GimpContainer *container;
GList *list;
GSList *merge_list = NULL;
GSList *invisible_list = NULL;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
if (merge_active_group)
{
GimpLayer *active_layer = gimp_image_get_active_layer (image);
/* if the active layer is the floating selection, get the
* underlying drawable, but only if it is a layer
*/
if (active_layer && gimp_layer_is_floating_sel (active_layer))
{
GimpDrawable *fs_drawable;
fs_drawable = gimp_layer_get_floating_sel_drawable (active_layer);
if (GIMP_IS_LAYER (fs_drawable))
active_layer = GIMP_LAYER (fs_drawable);
}
if (active_layer)
container = gimp_item_get_container (GIMP_ITEM (active_layer));
else
container = gimp_image_get_layers (image);
}
else
{
container = gimp_image_get_layers (image);
}
for (list = gimp_item_stack_get_item_iter (GIMP_ITEM_STACK (container));
list;
list = g_list_next (list))
{
GimpLayer *layer = list->data;
if (gimp_layer_is_floating_sel (layer))
continue;
if (gimp_item_get_visible (GIMP_ITEM (layer)))
{
merge_list = g_slist_append (merge_list, layer);
}
else if (discard_invisible)
{
invisible_list = g_slist_append (invisible_list, layer);
}
}
if (merge_list)
{
GimpLayer *layer;
gimp_set_busy (image->gimp);
gimp_image_undo_group_start (image,
GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE,
C_("undo-type", "Merge Visible Layers"));
/* if there's a floating selection, anchor it */
if (gimp_image_get_floating_selection (image))
floating_sel_anchor (gimp_image_get_floating_selection (image));
layer = gimp_image_merge_layers (image,
container,
merge_list, context, merge_type);
g_slist_free (merge_list);
if (invisible_list)
{
GSList *list;
for (list = invisible_list; list; list = g_slist_next (list))
gimp_image_remove_layer (image, list->data, TRUE, NULL);
g_slist_free (invisible_list);
}
gimp_image_undo_group_end (image);
gimp_unset_busy (image->gimp);
return layer;
}
return gimp_image_get_active_layer (image);
}
