static void
vectors_new_callback (GtkWidget *dialog,
GimpImage *image,
GimpVectors *vectors,
GimpContext *context,
const gchar *vectors_name,
gboolean vectors_visible,
gboolean vectors_linked,
GimpColorTag vectors_color_tag,
gboolean vectors_lock_content,
gboolean vectors_lock_position,
gpointer user_data)
{
GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
g_object_set (config,
"path-new-name", vectors_name,
NULL);
vectors = gimp_vectors_new (image, config->vectors_new_name);
gimp_item_set_visible (GIMP_ITEM (vectors), vectors_visible, FALSE);
gimp_item_set_linked (GIMP_ITEM (vectors), vectors_linked, FALSE);
gimp_item_set_color_tag (GIMP_ITEM (vectors), vectors_color_tag, FALSE);
gimp_item_set_lock_content (GIMP_ITEM (vectors), vectors_lock_content, FALSE);
gimp_item_set_lock_position (GIMP_ITEM (vectors), vectors_lock_position, FALSE);
gimp_image_add_vectors (image, vectors,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
gimp_image_flush (image);
gtk_widget_destroy (dialog);
}
void
drawable_linked_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GimpDrawable *drawable;
gboolean linked;
return_if_no_drawable (image, drawable, data);
linked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (GIMP_IS_LAYER_MASK (drawable))
drawable =
GIMP_DRAWABLE (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)));
if (linked != gimp_item_get_linked (GIMP_ITEM (drawable)))
{
GimpUndo *undo;
gboolean push_undo = TRUE;
undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
GIMP_UNDO_ITEM_LINKED);
if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (drawable))
push_undo = FALSE;
gimp_item_set_linked (GIMP_ITEM (drawable), linked, push_undo);
gimp_image_flush (image);
}
}
void
vectors_linked_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GimpVectors *vectors;
gboolean linked;
return_if_no_vectors (image, vectors, data);
linked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (linked != gimp_item_get_linked (GIMP_ITEM (vectors)))
{
GimpUndo *undo;
gboolean push_undo = TRUE;
undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
GIMP_UNDO_ITEM_LINKED);
if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (vectors))
push_undo = FALSE;
gimp_item_set_linked (GIMP_ITEM (vectors), linked, push_undo);
gimp_image_flush (image);
}
}
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 void
vectors_edit_attributes_callback (GtkWidget *dialog,
GimpImage *image,
GimpVectors *vectors,
GimpContext *context,
const gchar *vectors_name,
gboolean vectors_visible,
gboolean vectors_linked,
GimpColorTag vectors_color_tag,
gboolean vectors_lock_content,
gboolean vectors_lock_position,
gpointer user_data)
{
GimpItem *item = GIMP_ITEM (vectors);
if (strcmp (vectors_name, gimp_object_get_name (vectors)) ||
vectors_visible != gimp_item_get_visible (item) ||
vectors_linked != gimp_item_get_linked (item) ||
vectors_color_tag != gimp_item_get_color_tag (item) ||
vectors_lock_content != gimp_item_get_lock_content (item) ||
vectors_lock_position != gimp_item_get_lock_position (item))
{
gimp_image_undo_group_start (image,
GIMP_UNDO_GROUP_ITEM_PROPERTIES,
_("Path Attributes"));
if (strcmp (vectors_name, gimp_object_get_name (vectors)))
gimp_item_rename (GIMP_ITEM (vectors), vectors_name, NULL);
if (vectors_visible != gimp_item_get_visible (item))
gimp_item_set_visible (item, vectors_visible, TRUE);
if (vectors_linked != gimp_item_get_linked (item))
gimp_item_set_linked (item, vectors_linked, TRUE);
if (vectors_color_tag != gimp_item_get_color_tag (item))
gimp_item_set_color_tag (item, vectors_color_tag, TRUE);
if (vectors_lock_content != gimp_item_get_lock_content (item))
gimp_item_set_lock_content (item, vectors_lock_content, TRUE);
if (vectors_lock_position != gimp_item_get_lock_position (item))
gimp_item_set_lock_position (item, vectors_lock_position, TRUE);
gimp_image_undo_group_end (image);
gimp_image_flush (image);
}
gtk_widget_destroy (dialog);
}
gboolean
gimp_item_linked_is_locked (const GimpItem *item)
{
GList *list;
GList *l;
gboolean locked = FALSE;
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (gimp_item_get_linked (item) == TRUE, FALSE);
g_return_val_if_fail (gimp_item_is_attached (item), FALSE);
list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
GIMP_ITEM_TYPE_ALL,
GIMP_ITEM_SET_LINKED);
list = gimp_image_item_list_filter (item, list, TRUE, FALSE);
for (l = list; l && ! locked; l = g_list_next (l))
{
GimpItem *item = l->data;
/* temporarily set the item to not being linked, or we will
* run into a recursion because gimp_item_is_position_locked()
* call this function if the item is linked
*/
gimp_item_set_linked (item, FALSE, FALSE);
if (gimp_item_is_position_locked (item))
locked = TRUE;
gimp_item_set_linked (item, TRUE, FALSE);
}
g_list_free (list);
return locked;
}
static int
vectors_set_linked(PyGimpVectors *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "cannot delete linked");
return -1;
}
if (!PyInt_Check(value)) {
PyErr_SetString(PyExc_TypeError, "type mismatch");
return -1;
}
gimp_item_set_linked(self->ID, PyInt_AsLong(value));
return 0;
}
/**
* gimp_drawable_set_linked:
* @drawable_ID: The drawable.
* @linked: The new drawable linked state.
*
* Deprecated: Use gimp_item_set_linked() instead.
*
* Returns: TRUE on success.
*/
gboolean
gimp_drawable_set_linked (gint32 drawable_ID,
gboolean linked)
{
return gimp_item_set_linked (drawable_ID, linked);
}
static void
gimp_item_prop_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpItemPropUndo *item_prop_undo = GIMP_ITEM_PROP_UNDO (undo);
GimpItem *item = GIMP_ITEM_UNDO (undo)->item;
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_ITEM_REORDER:
{
GimpItem *parent;
gint position;
parent = gimp_item_get_parent (item);
position = gimp_item_get_index (item);
gimp_item_tree_reorder_item (gimp_item_get_tree (item), item,
item_prop_undo->parent,
item_prop_undo->position,
FALSE, NULL);
item_prop_undo->parent = parent;
item_prop_undo->position = position;
}
break;
case GIMP_UNDO_ITEM_RENAME:
{
gchar *name;
name = g_strdup (gimp_object_get_name (item));
gimp_item_tree_rename_item (gimp_item_get_tree (item), item,
item_prop_undo->name,
FALSE, NULL);
g_free (item_prop_undo->name);
item_prop_undo->name = name;
}
break;
case GIMP_UNDO_ITEM_DISPLACE:
{
gint offset_x;
gint offset_y;
gimp_item_get_offset (item, &offset_x, &offset_y);
gimp_item_translate (item,
item_prop_undo->offset_x - offset_x,
item_prop_undo->offset_y - offset_y,
FALSE);
item_prop_undo->offset_x = offset_x;
item_prop_undo->offset_y = offset_y;
}
break;
case GIMP_UNDO_ITEM_VISIBILITY:
{
gboolean visible;
visible = gimp_item_get_visible (item);
gimp_item_set_visible (item, item_prop_undo->visible, FALSE);
item_prop_undo->visible = visible;
}
break;
case GIMP_UNDO_ITEM_LINKED:
{
gboolean linked;
linked = gimp_item_get_linked (item);
gimp_item_set_linked (item, item_prop_undo->linked, FALSE);
item_prop_undo->linked = linked;
}
break;
case GIMP_UNDO_ITEM_COLOR_TAG:
{
GimpColorTag color_tag;
color_tag = gimp_item_get_color_tag (item);
gimp_item_set_color_tag (item, item_prop_undo->color_tag, FALSE);
item_prop_undo->color_tag = color_tag;
}
break;
case GIMP_UNDO_ITEM_LOCK_CONTENT:
{
gboolean lock_content;
lock_content = gimp_item_get_lock_content (item);
gimp_item_set_lock_content (item, item_prop_undo->lock_content, FALSE);
item_prop_undo->lock_content = lock_content;
}
break;
case GIMP_UNDO_ITEM_LOCK_POSITION:
{
gboolean lock_position;
lock_position = gimp_item_get_lock_position (item);
gimp_item_set_lock_position (item, item_prop_undo->lock_position, FALSE);
item_prop_undo->lock_position = lock_position;
}
break;
case GIMP_UNDO_PARASITE_ATTACH:
case GIMP_UNDO_PARASITE_REMOVE:
{
GimpParasite *parasite;
parasite = item_prop_undo->parasite;
item_prop_undo->parasite = gimp_parasite_copy
(gimp_item_parasite_find (item, item_prop_undo->parasite_name));
if (parasite)
gimp_item_parasite_attach (item, parasite, FALSE);
else
gimp_item_parasite_detach (item, item_prop_undo->parasite_name, FALSE);
if (parasite)
gimp_parasite_free (parasite);
}
break;
default:
g_assert_not_reached ();
}
}
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 = shell->display->image;
GType new_type;
GimpItem *new_item;
gboolean new_image = FALSE;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
{
GimpImage *src_image = gimp_item_get_image (GIMP_ITEM (viewable));
GimpDrawable *drawable = GIMP_DRAWABLE (viewable);
GimpImageBaseType type;
gdouble xres;
gdouble yres;
type = GIMP_IMAGE_TYPE_BASE_TYPE (gimp_drawable_type (drawable));
image = gimp_create_image (shell->display->gimp,
gimp_item_width (GIMP_ITEM (viewable)),
gimp_item_height (GIMP_ITEM (viewable)),
type, TRUE);
gimp_image_undo_disable (image);
if (type == GIMP_INDEXED)
gimp_image_set_colormap (image,
gimp_image_get_colormap (src_image),
gimp_image_get_colormap_size (src_image),
FALSE);
gimp_image_get_resolution (src_image, &xres, &yres);
gimp_image_set_resolution (image, xres, yres);
gimp_image_set_unit (image, gimp_image_get_unit (src_image));
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);
g_object_unref (image);
new_image = TRUE;
}
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"));
if (! new_image)
gimp_display_shell_dnd_position_item (shell, 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, -1);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
if (new_image)
gimp_image_undo_enable (image);
}
/**
* gimp_vectors_set_linked:
* @vectors_ID: The vectors object.
* @linked: Whether the path is linked.
*
* Deprecated: Use gimp_item_set_linked() instead.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.4
*/
gboolean
gimp_vectors_set_linked (gint32 vectors_ID,
gboolean linked)
{
return gimp_item_set_linked (vectors_ID, linked);
}
static void
gimp_item_prop_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpItemPropUndo *item_prop_undo = GIMP_ITEM_PROP_UNDO (undo);
GimpItem *item = GIMP_ITEM_UNDO (undo)->item;
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_ITEM_RENAME:
{
gchar *name;
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (item)));
gimp_object_take_name (GIMP_OBJECT (item), item_prop_undo->name);
item_prop_undo->name = name;
}
break;
case GIMP_UNDO_ITEM_DISPLACE:
{
gint offset_x;
gint offset_y;
gimp_item_offsets (item, &offset_x, &offset_y);
gimp_item_translate (item,
item_prop_undo->offset_x - offset_x,
item_prop_undo->offset_y - offset_y,
FALSE);
item_prop_undo->offset_x = offset_x;
item_prop_undo->offset_y = offset_y;
}
break;
case GIMP_UNDO_ITEM_VISIBILITY:
{
gboolean visible;
visible = gimp_item_get_visible (item);
gimp_item_set_visible (item, item_prop_undo->visible, FALSE);
item_prop_undo->visible = visible;
}
break;
case GIMP_UNDO_ITEM_LINKED:
{
gboolean linked;
linked = gimp_item_get_linked (item);
gimp_item_set_linked (item, item_prop_undo->linked, FALSE);
item_prop_undo->linked = linked;
}
break;
case GIMP_UNDO_PARASITE_ATTACH:
case GIMP_UNDO_PARASITE_REMOVE:
{
GimpParasite *parasite;
parasite = item_prop_undo->parasite;
item_prop_undo->parasite = gimp_parasite_copy
(gimp_item_parasite_find (item, item_prop_undo->parasite_name));
if (parasite)
gimp_parasite_list_add (item->parasites, parasite);
else
gimp_parasite_list_remove (item->parasites,
item_prop_undo->parasite_name);
if (parasite)
gimp_parasite_free (parasite);
}
break;
default:
g_assert_not_reached ();
}
}
