diff --git a/.gitignore b/.gitignore
index c5269c3..d6b91f5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,3 +46,11 @@
 /stamp-h
 /stamp-h.in
 /stamp-h1
+/.gitignore
+/.project
+/.cproject
+/.settings/
+/TODO-Layer-lock-translation
+
+
+
diff --git a/app/actions/drawable-actions.c b/app/actions/drawable-actions.c
index 10645fc..20438f2 100644
--- a/app/actions/drawable-actions.c
+++ b/app/actions/drawable-actions.c
@@ -89,7 +89,15 @@ static const GimpToggleActionEntry drawable_toggle_actions[] =
         "Keep the pixels on this drawable from being modified"),
     G_CALLBACK (drawable_lock_content_cmd_callback),
     FALSE,
-    NULL, /* GIMP_HELP_LAYER_LOCK_PIXELS */ }
+    NULL, /* GIMP_HELP_LAYER_LOCK_PIXELS */ },
+
+  { "drawable-lock-position", GIMP_STOCK_TOOL_MOVE,
+    NC_("drawable-action", "L_ock position of channel"), NULL,
+    NC_("drawable-action",
+        "Keep the position on this drawable from being modified"),
+    G_CALLBACK (drawable_lock_position_cmd_callback),
+    FALSE,
+    GIMP_HELP_LAYER_LOCK_POSITION },
 };
 
 static const GimpEnumActionEntry drawable_flip_actions[] =
@@ -165,15 +173,18 @@ drawable_actions_update (GimpActionGroup *group,
                          gpointer         data)
 {
   GimpImage    *image;
-  GimpDrawable *drawable   = NULL;
-  gboolean      is_rgb     = FALSE;
-  gboolean      is_indexed = FALSE;
-  gboolean      visible    = FALSE;
-  gboolean      linked     = FALSE;
-  gboolean      locked     = FALSE;
-  gboolean      can_lock   = FALSE;
-  gboolean      writable   = FALSE;
-  gboolean      children   = FALSE;
+  GimpDrawable *drawable        = NULL;
+  gboolean      is_rgb          = FALSE;
+  gboolean      is_indexed      = FALSE;
+  gboolean      visible         = FALSE;
+  gboolean      linked          = FALSE;
+  gboolean      locked          = FALSE;
+  gboolean      can_lock        = FALSE;
+  gboolean      locked_pos      = FALSE;
+  gboolean      can_lock_pos    = FALSE;
+  gboolean      writable        = FALSE;
+  gboolean      movable         = FALSE;
+  gboolean      children        = FALSE;
 
   image = action_data_get_image (data);
 
@@ -194,11 +205,14 @@ drawable_actions_update (GimpActionGroup *group,
           else
             item = GIMP_ITEM (drawable);
 
-          visible  = gimp_item_get_visible (item);
-          linked   = gimp_item_get_linked (item);
-          locked   = gimp_item_get_lock_content (item);
-          can_lock = gimp_item_can_lock_content (item);
-          writable = ! gimp_item_is_content_locked (item);
+          visible       = gimp_item_get_visible (item);
+          linked        = gimp_item_get_linked (item);
+          locked        = gimp_item_get_lock_content (item);
+          can_lock      = gimp_item_can_lock_content (item);
+          writable      = ! gimp_item_is_content_locked (item);
+          locked_pos    = gimp_item_get_lock_position (item);
+          can_lock_pos  = gimp_item_can_lock_position (item);
+          movable       = ! gimp_item_is_position_locked (item);
 
           if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
             children = TRUE;
@@ -213,22 +227,24 @@ drawable_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("drawable-equalize",       writable && !children && !is_indexed);
   SET_SENSITIVE ("drawable-invert",         writable && !children && !is_indexed);
   SET_SENSITIVE ("drawable-levels-stretch", writable && !children &&  is_rgb);
-  SET_SENSITIVE ("drawable-offset",         writable && !children);
+  SET_SENSITIVE ("drawable-offset",         writable && !children && movable);
 
   SET_SENSITIVE ("drawable-visible",      drawable);
   SET_SENSITIVE ("drawable-linked",       drawable);
   SET_SENSITIVE ("drawable-lock-content", can_lock);
+  SET_SENSITIVE ("drawable-lock-position",can_lock_pos);
 
   SET_ACTIVE ("drawable-visible",      visible);
   SET_ACTIVE ("drawable-linked",       linked);
   SET_ACTIVE ("drawable-lock-content", locked);
+  SET_ACTIVE ("drawable-lock-position",locked_pos);
 
-  SET_SENSITIVE ("drawable-flip-horizontal", writable);
-  SET_SENSITIVE ("drawable-flip-vertical",   writable);
+  SET_SENSITIVE ("drawable-flip-horizontal", writable && movable);
+  SET_SENSITIVE ("drawable-flip-vertical",   writable && movable);
 
-  SET_SENSITIVE ("drawable-rotate-90",  writable);
-  SET_SENSITIVE ("drawable-rotate-180", writable);
-  SET_SENSITIVE ("drawable-rotate-270", writable);
+  SET_SENSITIVE ("drawable-rotate-90",  writable && movable);
+  SET_SENSITIVE ("drawable-rotate-180", writable && movable);
+  SET_SENSITIVE ("drawable-rotate-270", writable && movable);
 
 #undef SET_SENSITIVE
 #undef SET_ACTIVE
diff --git a/app/actions/drawable-commands.c b/app/actions/drawable-commands.c
index 4847cc4..cb5b4cf 100644
--- a/app/actions/drawable-commands.c
+++ b/app/actions/drawable-commands.c
@@ -230,6 +230,38 @@ drawable_lock_content_cmd_callback (GtkAction *action,
     }
 }
 
+void
+drawable_lock_position_cmd_callback (GtkAction *action,
+                                    gpointer   data)
+{
+  GimpImage    *image;
+  GimpDrawable *drawable;
+  gboolean      locked;
+  return_if_no_drawable (image, drawable, data);
+
+  locked = 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 (locked != gimp_item_get_lock_position (GIMP_ITEM (drawable)))
+    {
+
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_LOCK_POSITION);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (drawable))
+        push_undo = FALSE;
+
+      gimp_item_set_lock_position (GIMP_ITEM (drawable), locked, push_undo);
+      gimp_image_flush (image);
+    }
+}
+
 
 void
 drawable_flip_cmd_callback (GtkAction *action,
diff --git a/app/actions/drawable-commands.h b/app/actions/drawable-commands.h
index a184384..2dc06fc 100644
--- a/app/actions/drawable-commands.h
+++ b/app/actions/drawable-commands.h
@@ -34,7 +34,8 @@ void   drawable_visible_cmd_callback        (GtkAction *action,
                                              gpointer   data);
 void   drawable_lock_content_cmd_callback   (GtkAction *action,
                                              gpointer   data);
-
+void   drawable_lock_position_cmd_callback  (GtkAction *action,
+                                             gpointer   data);
 void   drawable_flip_cmd_callback           (GtkAction *action,
                                              gint       value,
                                              gpointer   data);
diff --git a/app/actions/layers-actions.c b/app/actions/layers-actions.c
index 0a68fdc..fa17f52 100644
--- a/app/actions/layers-actions.c
+++ b/app/actions/layers-actions.c
@@ -242,6 +242,7 @@ static const GimpToggleActionEntry layers_toggle_actions[] =
     FALSE,
     GIMP_HELP_LAYER_LOCK_ALPHA },
 
+
   { "layers-mask-edit", GTK_STOCK_EDIT,
     NC_("layers-action", "_Edit Layer Mask"), NULL,
     NC_("layers-action", "Work on the layer mask"),
@@ -527,8 +528,10 @@ layers_actions_update (GimpActionGroup *group,
   gboolean       indexed        = FALSE;    /*  is indexed             */
   gboolean       lock_alpha     = FALSE;
   gboolean       can_lock_alpha = FALSE;
+
   gboolean       text_layer     = FALSE;
   gboolean       writable       = FALSE;
+  gboolean       movable        = FALSE;
   gboolean       children       = FALSE;
   GList         *next           = NULL;
   GList         *next_visible   = NULL;
@@ -551,8 +554,10 @@ layers_actions_update (GimpActionGroup *group,
           mask           = gimp_layer_get_mask (layer);
           lock_alpha     = gimp_layer_get_lock_alpha (layer);
           can_lock_alpha = gimp_layer_can_lock_alpha (layer);
+
           alpha          = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
           writable       = ! gimp_item_is_content_locked (GIMP_ITEM (layer));
+          movable        = ! gimp_item_is_position_locked (GIMP_ITEM (layer));
 
           if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
             children = TRUE;
@@ -639,9 +644,9 @@ layers_actions_update (GimpActionGroup *group,
   SET_VISIBLE   ("layers-text-to-vectors",          text_layer && !ac);
   SET_VISIBLE   ("layers-text-along-vectors",       text_layer && !ac);
 
-  SET_SENSITIVE ("layers-resize",          writable && !ac);
-  SET_SENSITIVE ("layers-resize-to-image", writable && !ac);
-  SET_SENSITIVE ("layers-scale",           writable && !ac);
+  SET_SENSITIVE ("layers-resize",          movable && !ac);
+  SET_SENSITIVE ("layers-resize-to-image", movable && !ac);
+  SET_SENSITIVE ("layers-scale",           movable && !ac);
 
   SET_SENSITIVE ("layers-crop",            writable && sel);
 
diff --git a/app/actions/layers-commands.c b/app/actions/layers-commands.c
index 0e72a69..0a4e78b 100644
--- a/app/actions/layers-commands.c
+++ b/app/actions/layers-commands.c
@@ -277,6 +277,9 @@ layers_new_last_vals_cmd_callback (GtkAction *action,
   return_if_no_image (image, data);
   return_if_no_widget (widget, data);
 
+//Remy:
+printf("run -> layers_new_last_vals_cmd_callback\n");
+
   /*  If there is a floating selection, the new command transforms
    *  the current fs into a new layer
    */
@@ -963,7 +966,6 @@ layers_lock_alpha_cmd_callback (GtkAction *action,
     }
 }
 
-
 /*  private functions  */
 
 static void
diff --git a/app/actions/vectors-actions.c b/app/actions/vectors-actions.c
index aad41ce..2a51c17 100644
--- a/app/actions/vectors-actions.c
+++ b/app/actions/vectors-actions.c
@@ -159,6 +159,12 @@ static const GimpToggleActionEntry vectors_toggle_actions[] =
     NC_("vectors-action", "L_ock strokes"), NULL, NULL,
     G_CALLBACK (vectors_lock_content_cmd_callback),
     FALSE,
+    NULL /* GIMP_HELP_PATH_LOCK_STROKES */ },
+
+  { "vectors-lock-position", NULL /* GIMP_STOCK_LOCK */,
+    NC_("vectors-action", "L_ock strokes"), NULL, NULL,
+    G_CALLBACK (vectors_lock_position_cmd_callback),
+    FALSE,
     NULL /* GIMP_HELP_PATH_LOCK_STROKES */ }
 };
 
@@ -252,7 +258,10 @@ vectors_actions_update (GimpActionGroup *group,
   gboolean      linked      = FALSE;
   gboolean      locked      = FALSE;
   gboolean      can_lock    = FALSE;
+  gboolean      locked_pos  = FALSE;
+  gboolean      can_lock_pos= FALSE;
   gboolean      dr_writable = FALSE;
+  gboolean      dr_movable  = FALSE;
   gboolean      dr_children = FALSE;
   GList        *next        = NULL;
   GList        *prev        = NULL;
@@ -270,11 +279,12 @@ vectors_actions_update (GimpActionGroup *group,
           GList    *vectors_list;
           GList    *list;
 
-          visible  = gimp_item_get_visible (item);
-          linked   = gimp_item_get_linked (item);
-          locked   = gimp_item_get_lock_content (item);
-          can_lock = gimp_item_can_lock_content (item);
-
+          visible      = gimp_item_get_visible (item);
+          linked       = gimp_item_get_linked (item);
+          locked       = gimp_item_get_lock_content (item);
+          can_lock     = gimp_item_can_lock_content (item);
+          locked_pos   = gimp_item_get_lock_position (item);
+          can_lock_pos = gimp_item_can_lock_position (item);
           vectors_list = gimp_item_get_container_iter (item);
 
           list = g_list_find (vectors_list, vectors);
@@ -293,6 +303,7 @@ vectors_actions_update (GimpActionGroup *group,
           GimpItem *item = GIMP_ITEM (drawable);
 
           dr_writable = ! gimp_item_is_content_locked (item);
+          dr_movable  = ! gimp_item_is_position_locked (item);
 
           if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))
             dr_children = TRUE;
@@ -326,19 +337,23 @@ vectors_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("vectors-visible",      vectors);
   SET_SENSITIVE ("vectors-linked",       vectors);
   SET_SENSITIVE ("vectors-lock-content", can_lock);
+  SET_SENSITIVE ("vectors-lock-position",can_lock_pos);
 
   SET_ACTIVE ("vectors-visible",      visible);
   SET_ACTIVE ("vectors-linked",       linked);
   SET_ACTIVE ("vectors-lock-content", locked);
+  SET_ACTIVE ("vectors-lock-position",locked_pos);
 
   SET_SENSITIVE ("vectors-selection-to-vectors",          image && !mask_empty);
   SET_SENSITIVE ("vectors-selection-to-vectors-short",    image && !mask_empty);
   SET_SENSITIVE ("vectors-selection-to-vectors-advanced", image && !mask_empty);
   SET_SENSITIVE ("vectors-stroke",                        vectors &&
                                                           dr_writable &&
+                                                          dr_movable  &&
                                                           !dr_children);
   SET_SENSITIVE ("vectors-stroke-last-values",            vectors &&
                                                           dr_writable &&
+                                                          dr_movable  &&
                                                           !dr_children);
 
   SET_SENSITIVE ("vectors-selection-replace",      vectors);
diff --git a/app/actions/vectors-commands.c b/app/actions/vectors-commands.c
index 5a6c1b5..9bfc3b1 100644
--- a/app/actions/vectors-commands.c
+++ b/app/actions/vectors-commands.c
@@ -638,6 +638,33 @@ vectors_lock_content_cmd_callback (GtkAction *action,
     }
 }
 
+void
+vectors_lock_position_cmd_callback (GtkAction *action,
+                                   gpointer   data)
+{
+  GimpImage   *image;
+  GimpVectors *vectors;
+  gboolean     locked;
+  return_if_no_vectors (image, vectors, data);
+
+  locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+
+  if (locked != gimp_item_get_lock_position (GIMP_ITEM (vectors)))
+    {
+      GimpUndo *undo;
+      gboolean  push_undo = TRUE;
+
+      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                           GIMP_UNDO_ITEM_LOCK_POSITION);
+
+      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (vectors))
+        push_undo = FALSE;
+
+
+      gimp_item_set_lock_position (GIMP_ITEM (vectors), locked, push_undo);
+      gimp_image_flush (image);
+    }
+}
 
 /*  private functions  */
 
diff --git a/app/actions/vectors-commands.h b/app/actions/vectors-commands.h
index 40118c0..625c37d 100644
--- a/app/actions/vectors-commands.h
+++ b/app/actions/vectors-commands.h
@@ -69,6 +69,7 @@ void   vectors_linked_cmd_callback               (GtkAction   *action,
                                                   gpointer     data);
 void   vectors_lock_content_cmd_callback         (GtkAction   *action,
                                                   gpointer     data);
-
+void   vectors_lock_position_cmd_callback        (GtkAction   *action,
+                                                  gpointer     data);
 
 #endif /* __VECTORS_COMMANDS_H__ */
diff --git a/app/core/core-enums.c b/app/core/core-enums.c
index cf6e9ce..d952c3d 100644
--- a/app/core/core-enums.c
+++ b/app/core/core-enums.c
@@ -797,6 +797,7 @@ gimp_undo_type_get_type (void)
     { GIMP_UNDO_ITEM_DISPLACE, "GIMP_UNDO_ITEM_DISPLACE", "item-displace" },
     { GIMP_UNDO_ITEM_VISIBILITY, "GIMP_UNDO_ITEM_VISIBILITY", "item-visibility" },
     { GIMP_UNDO_ITEM_LINKED, "GIMP_UNDO_ITEM_LINKED", "item-linked" },
+    { GIMP_UNDO_ITEM_LOCK_POSITION, "GIMP_UNDO_ITEM_LOCK_POSITION", "item-lock-position" },
     { GIMP_UNDO_LAYER_ADD, "GIMP_UNDO_LAYER_ADD", "layer-add" },
     { GIMP_UNDO_LAYER_REMOVE, "GIMP_UNDO_LAYER_REMOVE", "layer-remove" },
     { GIMP_UNDO_LAYER_MODE, "GIMP_UNDO_LAYER_MODE", "layer-mode" },
@@ -883,6 +884,7 @@ gimp_undo_type_get_type (void)
     { GIMP_UNDO_ITEM_DISPLACE, NC_("undo-type", "Move item"), NULL },
     { GIMP_UNDO_ITEM_VISIBILITY, NC_("undo-type", "Item visibility"), NULL },
     { GIMP_UNDO_ITEM_LINKED, NC_("undo-type", "Link/Unlink item"), NULL },
+    { GIMP_UNDO_ITEM_LOCK_POSITION, NC_("undo-type", "Lock/Unlock position"), NULL },
     { GIMP_UNDO_LAYER_ADD, NC_("undo-type", "New layer"), NULL },
     { GIMP_UNDO_LAYER_REMOVE, NC_("undo-type", "Delete layer"), NULL },
     { GIMP_UNDO_LAYER_MODE, NC_("undo-type", "Set layer mode"), NULL },
diff --git a/app/core/core-enums.h b/app/core/core-enums.h
index e2edea3..3b7a171 100644
--- a/app/core/core-enums.h
+++ b/app/core/core-enums.h
@@ -400,6 +400,7 @@ typedef enum /*< pdb-skip >*/
   GIMP_UNDO_ITEM_DISPLACE,            /*< desc="Move item"                   >*/
   GIMP_UNDO_ITEM_VISIBILITY,          /*< desc="Item visibility"             >*/
   GIMP_UNDO_ITEM_LINKED,              /*< desc="Link/Unlink item"            >*/
+  GIMP_UNDO_ITEM_LOCK_POSITION,       /*< desc="Lock/Unlock position"        >*/
   GIMP_UNDO_LAYER_ADD,                /*< desc="New layer"                   >*/
   GIMP_UNDO_LAYER_REMOVE,             /*< desc="Delete layer"                >*/
   GIMP_UNDO_LAYER_MODE,               /*< desc="Set layer mode"              >*/
@@ -683,5 +684,12 @@ typedef enum  /*< pdb-skip, skip >*/
                              GIMP_ITEM_TYPE_VECTORS)
 } GimpItemTypeMask;
 
+typedef enum /*< pdb-skip, skip >*/
+{
+	GIMP_LOCK_PIXELS,
+	GIMP_LOCK_ALPHA,
+	GIMP_LOCK_POSITION
+
+} GimpLockType;
 
 #endif /* __CORE_ENUMS_H__ */
diff --git a/app/core/gimpgrouplayer.c b/app/core/gimpgrouplayer.c
index 3a31c6d..85f4374 100644
--- a/app/core/gimpgrouplayer.c
+++ b/app/core/gimpgrouplayer.c
@@ -36,6 +36,7 @@
 #include "gimpimage-undo-push.h"
 #include "gimpdrawable-private.h" /* eek */
 #include "gimpdrawablestack.h"
+#include "gimpitem-linked.h"
 #include "gimppickable.h"
 #include "gimpprojectable.h"
 #include "gimpprojection.h"
@@ -487,6 +488,7 @@ gimp_group_layer_convert (GimpItem  *item,
   GIMP_ITEM_CLASS (parent_class)->convert (item, dest_image);
 }
 
+
 static void
 gimp_group_layer_translate (GimpItem *item,
                             gint      offset_x,
@@ -498,6 +500,10 @@ gimp_group_layer_translate (GimpItem *item,
   GimpLayerMask         *mask;
   GList                 *list;
 
+  //Remy: stop translate if group has any move-locked layers!
+  if(gimp_group_layer_has_locked_children(item,GIMP_LOCK_POSITION))
+        return;
+
   /*  don't push an undo here because undo will call us again  */
   gimp_group_layer_suspend_resize (group, FALSE);
 
@@ -1001,6 +1007,43 @@ gimp_group_layer_resume_resize (GimpGroupLayer *group,
     }
 }
 
+gboolean
+gimp_group_layer_has_locked_children (const GimpItem *item,
+                                      GimpLockType lock_type)
+{
+  GimpGroupLayerPrivate *private = GET_PRIVATE (item);
+
+  gint n_children = gimp_container_get_n_children(private->children);
+  gint i;
+  for (i=0; i<n_children; ++i)
+    {
+      GimpObject *children = gimp_container_get_child_by_index(private->children,i);
+      if(GIMP_IS_LAYER(children))
+        {
+          GimpLayer *layer = GIMP_LAYER(children);
+          if(lock_type==GIMP_LOCK_ALPHA)
+            {
+              if(gimp_layer_get_lock_alpha(layer))
+                return TRUE;
+            }
+          else if(lock_type==GIMP_LOCK_POSITION)
+            {
+              if(gimp_item_get_lock_position (GIMP_ITEM(layer)))
+                return TRUE;
+              else if(gimp_item_get_linked (GIMP_ITEM(layer)))
+                if(gimp_item_linked_has_locked_items (GIMP_ITEM(layer),GIMP_LOCK_POSITION))
+                  return TRUE;
+            }
+          //Remy: if pixels locked:
+          else
+            {
+              if(gimp_item_get_lock_content (GIMP_ITEM(layer)))
+                return TRUE;
+            }
+        }
+    }
+  return FALSE;
+}
 
 /*  private functions  */
 
diff --git a/app/core/gimpgrouplayer.h b/app/core/gimpgrouplayer.h
index db0169f..7f8a230 100644
--- a/app/core/gimpgrouplayer.h
+++ b/app/core/gimpgrouplayer.h
@@ -56,6 +56,8 @@ void             gimp_group_layer_suspend_resize (GimpGroupLayer *group,
                                                   gboolean        push_undo);
 void             gimp_group_layer_resume_resize  (GimpGroupLayer *group,
                                                   gboolean        push_undo);
-
+gboolean  gimp_group_layer_has_locked_children
+                                                  (const GimpItem *item,
+                                                   GimpLockType lock_type);
 
 #endif /* __GIMP_GROUP_LAYER_H__ */
diff --git a/app/core/gimpimage-undo-push.c b/app/core/gimpimage-undo-push.c
index ec071f1..0973cd3 100644
--- a/app/core/gimpimage-undo-push.c
+++ b/app/core/gimpimage-undo-push.c
@@ -417,6 +417,21 @@ gimp_image_undo_push_item_parasite_remove (GimpImage   *image,
                                NULL);
 }
 
+GimpUndo *
+gimp_image_undo_push_item_lock_position (GimpImage   *image,
+                                       const gchar *undo_desc,
+                                       GimpItem   *item)
+{
+  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
+  g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
+  g_return_val_if_fail (gimp_item_is_attached (item), NULL);
+
+  return gimp_image_undo_push (image, GIMP_TYPE_ITEM_PROP_UNDO,
+                               GIMP_UNDO_ITEM_LOCK_POSITION, undo_desc,
+                               GIMP_DIRTY_ITEM_META,
+                               "item", item,
+                               NULL);
+}
 
 /*****************/
 /*  Layer Undos  */
@@ -516,7 +531,6 @@ gimp_image_undo_push_layer_lock_alpha (GimpImage   *image,
                                NULL);
 }
 
-
 /***********************/
 /*  Group Layer Undos  */
 /***********************/
diff --git a/app/core/gimpimage-undo-push.h b/app/core/gimpimage-undo-push.h
index 8baea0c..5289805 100644
--- a/app/core/gimpimage-undo-push.h
+++ b/app/core/gimpimage-undo-push.h
@@ -103,6 +103,9 @@ GimpUndo * gimp_image_undo_push_item_parasite_remove(GimpImage     *image,
                                                      const gchar   *undo_desc,
                                                      GimpItem      *item,
                                                      const gchar   *name);
+GimpUndo * gimp_image_undo_push_item_lock_position  (GimpImage   *image,
+                                                     const gchar *undo_desc,
+                                                     GimpItem   *item);
 
 
 /*  layer undos  */
diff --git a/app/core/gimpitem-linked.c b/app/core/gimpitem-linked.c
index aa41723..9fc2c1a 100644
--- a/app/core/gimpitem-linked.c
+++ b/app/core/gimpitem-linked.c
@@ -24,6 +24,10 @@
 #include "gimpcontext.h"
 #include "gimpimage.h"
 #include "gimpimage-item-list.h"
+#include "gimplayer.h"
+#include "gimpgrouplayer.h"
+#include "gimpchannel.h"
+#include "../vectors/gimpvectors.h"
 #include "gimpitem.h"
 #include "gimpitem-linked.h"
 #include "gimplist.h"
@@ -32,6 +36,74 @@
 
 /*  public functions  */
 
+/*Remy!
+ * Для перемещения:
+ * Добавить проход по вложенным слоям для слоя-группы для поиска среди них фиксированных !
+ */
+
+gboolean
+gimp_item_linked_has_locked_items(const GimpItem *item,GimpLockType lock_type)
+{
+  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);
+
+  GimpItemTypeMask  item_type = GIMP_ITEM_TYPE_ALL;
+
+  if(GIMP_IS_LAYER(item))
+    item_type = GIMP_ITEM_TYPE_LAYERS;
+  else if(GIMP_IS_CHANNEL(item))
+    item_type = GIMP_ITEM_TYPE_CHANNELS;
+  else if(GIMP_IS_VECTORS(item))
+    item_type = GIMP_ITEM_TYPE_VECTORS;
+
+  /* For items */
+  if(item_type != GIMP_ITEM_TYPE_ALL)
+    {
+      GList *list = NULL;
+      GList *l = NULL;
+
+      list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
+                                            item_type,
+                                            GIMP_ITEM_SET_LINKED);
+      list = gimp_image_item_list_filter (item, list, TRUE, FALSE);
+
+
+      if(lock_type == GIMP_LOCK_POSITION)
+        {
+          for (l = list; l; l = g_list_next (l)){
+              GimpItem *item = GIMP_ITEM(l->data);
+              if(GIMP_IS_GROUP_LAYER(item))
+                {
+                if(gimp_group_layer_has_locked_children(item,GIMP_LOCK_POSITION))
+                  return TRUE;
+                }
+                else
+                  {
+                    if(gimp_item_get_lock_position(item))
+                      return TRUE;
+                  }
+          }
+        }
+      else if(lock_type == GIMP_LOCK_ALPHA && item_type == GIMP_ITEM_TYPE_LAYERS)
+        {
+          for (l = list; l; l = g_list_next (l))
+                 if(gimp_layer_get_lock_alpha(GIMP_LAYER(l->data)))
+                   return TRUE;
+        }
+      //Remy: if pixels locked:
+      else
+        {
+          GList *l;
+          for (l = list; l; l = g_list_next (l))
+                 if(gimp_item_get_lock_content(GIMP_ITEM(l->data)))
+                   return TRUE;
+        }
+  }
+
+  return FALSE;
+}
+
 void
 gimp_item_linked_translate (GimpItem *item,
                             gint      offset_x,
diff --git a/app/core/gimpitem-linked.h b/app/core/gimpitem-linked.h
index 759361b..23e990c 100644
--- a/app/core/gimpitem-linked.h
+++ b/app/core/gimpitem-linked.h
@@ -19,6 +19,8 @@
 #define __GIMP_ITEM_LINKED_H__
 
 
+gboolean gimp_item_linked_has_locked_items
+                                  (const GimpItem *item,GimpLockType lock_type);
 void   gimp_item_linked_translate (GimpItem               *item,
                                    gint                    offset_x,
                                    gint                    offset_y,
diff --git a/app/core/gimpitem.c b/app/core/gimpitem.c
index a7a142d..e988d4b 100644
--- a/app/core/gimpitem.c
+++ b/app/core/gimpitem.c
@@ -37,6 +37,9 @@
 #include "gimpitem.h"
 #include "gimpitem-preview.h"
 #include "gimpitemtree.h"
+#include "gimpitem-linked.h"
+#include "gimplayer.h"
+#include "gimpgrouplayer.h"
 #include "gimplist.h"
 #include "gimpmarshal.h"
 #include "gimpparasitelist.h"
@@ -52,6 +55,7 @@ enum
   VISIBILITY_CHANGED,
   LINKED_CHANGED,
   LOCK_CONTENT_CHANGED,
+  LOCK_POSITION_CHANGED,
   LAST_SIGNAL
 };
 
@@ -66,7 +70,8 @@ enum
   PROP_OFFSET_Y,
   PROP_VISIBLE,
   PROP_LINKED,
-  PROP_LOCK_CONTENT
+  PROP_LOCK_CONTENT,
+  PROP_LOCK_POSITION
 };
 
 
@@ -87,6 +92,7 @@ struct _GimpItemPrivate
   guint             visible      : 1;   /*  control visibility       */
   guint             linked       : 1;   /*  control linkage          */
   guint             lock_content : 1;   /*  content editability      */
+  guint             lock_position: 1;   /*  content movability      */
 
   guint             removed : 1;        /*  removed from the image?  */
 
@@ -119,6 +125,7 @@ static gint64     gimp_item_get_memsize             (GimpObject     *object,
 static void       gimp_item_real_visibility_changed (GimpItem       *item);
 
 static gboolean   gimp_item_real_is_content_locked  (const GimpItem *item);
+static gboolean   gimp_item_real_is_position_locked (const GimpItem *item);
 static GimpItem * gimp_item_real_duplicate          (GimpItem       *item,
                                                      GType           new_type);
 static void       gimp_item_real_convert            (GimpItem       *item,
@@ -198,6 +205,15 @@ gimp_item_class_init (GimpItemClass *klass)
                   gimp_marshal_VOID__VOID,
                   G_TYPE_NONE, 0);
 
+  gimp_item_signals[LOCK_POSITION_CHANGED] =
+    g_signal_new ("lock-position-changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (GimpItemClass, lock_position_changed),
+                  NULL, NULL,
+                  gimp_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
   object_class->constructed        = gimp_item_constructed;
   object_class->finalize           = gimp_item_finalize;
   object_class->set_property       = gimp_item_set_property;
@@ -212,10 +228,12 @@ gimp_item_class_init (GimpItemClass *klass)
   klass->visibility_changed        = gimp_item_real_visibility_changed;
   klass->linked_changed            = NULL;
   klass->lock_content_changed      = NULL;
+  klass->lock_position_changed     = NULL;
 
   klass->unset_removed             = NULL;
   klass->is_attached               = NULL;
   klass->is_content_locked         = gimp_item_real_is_content_locked;
+  klass->is_position_locked        = gimp_item_real_is_position_locked;
   klass->get_tree                  = NULL;
   klass->duplicate                 = gimp_item_real_duplicate;
   klass->convert                   = gimp_item_real_convert;
@@ -287,6 +305,12 @@ gimp_item_class_init (GimpItemClass *klass)
                                                          FALSE,
                                                          GIMP_PARAM_READABLE));
 
+  g_object_class_install_property (object_class, PROP_LOCK_POSITION,
+                                   g_param_spec_boolean ("lock-position",
+                                                         NULL, NULL,
+                                                         FALSE,
+                                                         GIMP_PARAM_READABLE));
+
   g_type_class_add_private (klass, sizeof (GimpItemPrivate));
 }
 
@@ -308,6 +332,7 @@ gimp_item_init (GimpItem *item)
   private->visible      = TRUE;
   private->linked       = FALSE;
   private->lock_content = FALSE;
+  private->lock_position= FALSE;
   private->removed      = FALSE;
   private->node         = NULL;
   private->offset_node  = NULL;
@@ -408,6 +433,9 @@ gimp_item_get_property (GObject    *object,
     case PROP_LOCK_CONTENT:
       g_value_set_boolean (value, private->lock_content);
       break;
+    case PROP_LOCK_POSITION:
+      g_value_set_boolean (value, private->lock_position);
+      break;
 
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@@ -462,6 +490,28 @@ gimp_item_real_is_content_locked (const GimpItem *item)
   return GET_PRIVATE (item)->lock_content;
 }
 
+
+//Remy! Искать связанные или сгрупированные фиксир. слои!
+static gboolean
+gimp_item_real_is_position_locked (const GimpItem *item)
+{
+//Если группа, то ищем фиксю в группе
+  if(GIMP_IS_GROUP_LAYER(item))
+      if(gimp_group_layer_has_locked_children(item,GIMP_LOCK_POSITION))
+          return TRUE;
+
+
+  //Если связанный слой или группа или вектор или канал, ищем если среди них фиксированные
+  //чтоб запретить перемещ. и  транф.
+  if(gimp_item_get_linked(item))
+      if(gimp_item_linked_has_locked_items(item,GIMP_LOCK_POSITION))
+          return TRUE;
+
+  //Если ни группа и ни связанный не содержат фиксированных,
+  //тогда возвращаем состояние этого итема!
+  return GET_PRIVATE (item)->lock_position;
+}
+
 static GimpItem *
 gimp_item_real_duplicate (GimpItem *item,
                           GType     new_type)
@@ -524,6 +574,11 @@ gimp_item_real_duplicate (GimpItem *item,
     gimp_item_set_lock_content (new_item, gimp_item_get_lock_content (item),
                                 FALSE);
 
+  if (gimp_item_can_lock_position (new_item))
+    gimp_item_set_lock_position (new_item, gimp_item_get_lock_position (item),
+                                FALSE);
+
+
   return new_item;
 }
 
@@ -1733,6 +1788,7 @@ gimp_item_replace_item (GimpItem *item,
   gimp_item_set_visible      (item, gimp_item_get_visible (replace), FALSE);
   gimp_item_set_linked       (item, gimp_item_get_linked (replace), FALSE);
   gimp_item_set_lock_content (item, gimp_item_get_lock_content (replace), FALSE);
+  gimp_item_set_lock_position(item, gimp_item_get_lock_position (replace), FALSE);
 }
 
 /**
@@ -2059,6 +2115,9 @@ gimp_item_can_lock_content (const GimpItem *item)
 {
   g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
 
+  if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))
+    return FALSE;
+
   return TRUE;
 }
 
@@ -2070,6 +2129,62 @@ gimp_item_is_content_locked (const GimpItem *item)
   return GIMP_ITEM_GET_CLASS (item)->is_content_locked (item);
 }
 
+/* Lock position methods: */
+void
+gimp_item_set_lock_position (GimpItem *item,
+                             gboolean  lock_position,
+                             gboolean  push_undo)
+{
+  g_return_if_fail (GIMP_IS_ITEM (item));
+  g_return_if_fail (gimp_item_can_lock_position (item));
+
+  lock_position = lock_position ? TRUE : FALSE;
+
+  if (gimp_item_get_lock_position (item) != lock_position)
+    {
+      if (push_undo && gimp_item_is_attached (item))
+        {
+          GimpImage *image = gimp_item_get_image (item);
+
+          gimp_image_undo_push_item_lock_position (image, NULL, item);
+        }
+
+      GET_PRIVATE (item)->lock_position = lock_position;
+
+      g_signal_emit (item, gimp_item_signals[LOCK_POSITION_CHANGED], 0);
+
+      g_object_notify (G_OBJECT (item), "lock-position");
+    }
+}
+
+gboolean
+gimp_item_get_lock_position (const GimpItem *item)
+{
+  g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
+
+  return GET_PRIVATE (item)->lock_position;
+}
+
+//Remy! Add validation for item!
+gboolean
+gimp_item_can_lock_position (const GimpItem *item)
+{
+  g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
+
+  if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))
+    return FALSE;
+
+  return TRUE;
+}
+
+gboolean
+gimp_item_is_position_locked (const GimpItem *item)
+{
+  g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
+
+  return GIMP_ITEM_GET_CLASS (item)->is_position_locked (item);
+}
+
 gboolean
 gimp_item_mask_bounds (GimpItem *item,
                        gint     *x1,
diff --git a/app/core/gimpitem.h b/app/core/gimpitem.h
index cc6f01b..e574f94 100644
--- a/app/core/gimpitem.h
+++ b/app/core/gimpitem.h
@@ -46,11 +46,13 @@ struct _GimpItemClass
   void            (* visibility_changed)   (GimpItem             *item);
   void            (* linked_changed)       (GimpItem             *item);
   void            (* lock_content_changed) (GimpItem             *item);
+  void            (* lock_position_changed)(GimpItem             *item);
 
   /*  virtual functions  */
   void            (* unset_removed)      (GimpItem               *item);
   gboolean        (* is_attached)        (const GimpItem         *item);
   gboolean        (* is_content_locked)  (const GimpItem         *item);
+  gboolean        (* is_position_locked) (const GimpItem         *item);
   GimpItemTree  * (* get_tree)           (GimpItem               *item);
   GimpItem      * (* duplicate)          (GimpItem               *item,
                                           GType                   new_type);
@@ -305,6 +307,13 @@ gboolean        gimp_item_get_lock_content   (const GimpItem     *item);
 gboolean        gimp_item_can_lock_content   (const GimpItem     *item);
 gboolean        gimp_item_is_content_locked  (const GimpItem     *item);
 
+void            gimp_item_set_lock_position  (GimpItem *item,
+                                              gboolean  lock_position,
+                                              gboolean  push_undo);
+gboolean        gimp_item_get_lock_position  (const GimpItem *item);
+gboolean        gimp_item_can_lock_position  (const GimpItem *item);
+gboolean        gimp_item_is_position_locked  (const GimpItem *item);
+
 gboolean        gimp_item_mask_bounds        (GimpItem           *item,
                                               gint               *x1,
                                               gint               *y1,
diff --git a/app/core/gimpitempropundo.c b/app/core/gimpitempropundo.c
index 9413f3b..966a031 100644
--- a/app/core/gimpitempropundo.c
+++ b/app/core/gimpitempropundo.c
@@ -135,6 +135,10 @@ gimp_item_prop_undo_constructed (GObject *object)
         (gimp_item_parasite_find (item, item_prop_undo->parasite_name));
       break;
 
+    case GIMP_UNDO_ITEM_LOCK_POSITION:
+      item_prop_undo->lock_position = gimp_item_get_lock_position (item);
+      break;
+
     default:
       g_assert_not_reached ();
     }
@@ -297,6 +301,16 @@ gimp_item_prop_undo_pop (GimpUndo            *undo,
       }
       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;
+
     default:
       g_assert_not_reached ();
     }
diff --git a/app/core/gimpitempropundo.h b/app/core/gimpitempropundo.h
index e20eb13..be99693 100644
--- a/app/core/gimpitempropundo.h
+++ b/app/core/gimpitempropundo.h
@@ -45,6 +45,7 @@ struct _GimpItemPropUndo
   gboolean      linked;
   gchar        *parasite_name;
   GimpParasite *parasite;
+  gboolean      lock_position;
 };
 
 struct _GimpItemPropUndoClass
diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c
index 5666d27..70f4e0d 100644
--- a/app/core/gimplayer.c
+++ b/app/core/gimplayer.c
@@ -311,6 +311,7 @@ gimp_layer_class_init (GimpLayerClass *klass)
                                                          FALSE,
                                                          GIMP_PARAM_READABLE));
 
+
   g_object_class_install_property (object_class, PROP_MASK,
                                    g_param_spec_object ("mask",
                                                         NULL, NULL,
@@ -2122,3 +2123,5 @@ gimp_layer_can_lock_alpha (const GimpLayer *layer)
 
   return TRUE;
 }
+
+
diff --git a/app/core/gimplayerpropundo.c b/app/core/gimplayerpropundo.c
index 636c9ab..3b30ceb 100644
--- a/app/core/gimplayerpropundo.c
+++ b/app/core/gimplayerpropundo.c
@@ -130,6 +130,7 @@ gimp_layer_prop_undo_pop (GimpUndo            *undo,
       }
       break;
 
+
     default:
       g_assert_not_reached ();
     }
diff --git a/app/display/gimpdisplayshell-dnd.c b/app/display/gimpdisplayshell-dnd.c
index 0d78fb0..7ff9481 100644
--- a/app/display/gimpdisplayshell-dnd.c
+++ b/app/display/gimpdisplayshell-dnd.c
@@ -326,6 +326,7 @@ gimp_display_shell_dnd_bucket_fill (GimpDisplayShell   *shell,
                                     const GimpRGB      *color,
                                     GimpPattern        *pattern)
 {
+  printf("gimp_display_shell_dnd_bucket_fill!\n");
   GimpImage    *image = gimp_display_get_image (shell->display);
   GimpDrawable *drawable;
 
@@ -417,6 +418,7 @@ gimp_display_shell_drop_buffer (GtkWidget    *widget,
                                 GimpViewable *viewable,
                                 gpointer      data)
 {
+  printf("gimp_display_shell_drop_buffer!\n");
   GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data);
   GimpImage        *image = gimp_display_get_image (shell->display);
   GimpDrawable     *drawable;
diff --git a/app/tools/gimpmovetool.c b/app/tools/gimpmovetool.c
index 39b9b5d..5f39c47 100644
--- a/app/tools/gimpmovetool.c
+++ b/app/tools/gimpmovetool.c
@@ -36,10 +36,12 @@
 #include "core/gimpimage-guides.h"
 #include "core/gimpimage-pick-layer.h"
 #include "core/gimplayer.h"
+#include "core/gimpgrouplayer.h"
 #include "core/gimpimage-undo.h"
 #include "core/gimplayermask.h"
 #include "core/gimplayer-floating-sel.h"
 #include "core/gimpundostack.h"
+#include "core/gimperror.h"
 
 #include "widgets/gimphelp-ids.h"
 #include "widgets/gimpwidgets-utils.h"
@@ -115,6 +117,9 @@ G_DEFINE_TYPE (GimpMoveTool, gimp_move_tool, GIMP_TYPE_DRAW_TOOL)
 #define parent_class gimp_move_tool_parent_class
 
 
+
+
+
 void
 gimp_move_tool_register (GimpToolRegisterCallback  callback,
                          gpointer                  data)
@@ -186,6 +191,9 @@ gimp_move_tool_button_press (GimpTool            *tool,
   GimpMoveOptions  *options = GIMP_MOVE_TOOL_GET_OPTIONS (tool);
   GimpDisplayShell *shell   = gimp_display_get_shell (display);
   GimpImage        *image   = gimp_display_get_image (display);
+  GimpItem         *active_item    = NULL;
+  const gchar      *null_message   = NULL;
+  const gchar      *locked_message = NULL;
 
   tool->display = display;
 
@@ -289,48 +297,104 @@ gimp_move_tool_button_press (GimpTool            *tool,
   switch (options->move_type)
     {
     case GIMP_TRANSFORM_TYPE_PATH:
-      if (gimp_image_get_active_vectors (image))
+      {
+      active_item = GIMP_ITEM (gimp_image_get_active_vectors (image));
+      null_message   = _("There is no path to translation.");
+      locked_message = _("The active path is locked from translation.");
+      if (active_item)
         {
-          gimp_tool_control_activate (tool->control);
-          gimp_edit_selection_tool_start (tool, display, coords,
+          if(!gimp_item_is_position_locked (active_item))
+            {
+              gimp_tool_control_activate (tool->control);
+              gimp_edit_selection_tool_start (tool, display, coords,
                                           GIMP_TRANSLATE_MODE_VECTORS, TRUE);
+              return;
+            }
         }
+      }
       break;
 
     case GIMP_TRANSFORM_TYPE_SELECTION:
-      if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
+      {
+      active_item = GIMP_ITEM (gimp_image_get_mask (image));
+      /* cannot happen, so don't translate these messages */
+      null_message   = "There is no selection to translation.";
+      locked_message = "The selection is locked from translation.";
+      if(active_item)
         {
-          gimp_tool_control_activate (tool->control);
-          gimp_edit_selection_tool_start (tool, display, coords,
-                                          GIMP_TRANSLATE_MODE_MASK, TRUE);
+          if(!gimp_item_is_position_locked (active_item))
+            {
+              if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
+              {
+                gimp_tool_control_activate (tool->control);
+                gimp_edit_selection_tool_start (tool, display, coords,
+                                                GIMP_TRANSLATE_MODE_MASK, TRUE);
+                return;
+              }
+              else
+                locked_message = "The selection is empty.";
+            }
         }
+      }
       break;
 
     case GIMP_TRANSFORM_TYPE_LAYER:
       {
-        GimpDrawable *drawable = gimp_image_get_active_drawable (image);
+        active_item = GIMP_ITEM (gimp_image_get_active_drawable (image));
+        null_message   = _("There is no layer to translation.");
 
-        if (GIMP_IS_LAYER_MASK (drawable))
-          {
-            gimp_tool_control_activate (tool->control);
-            gimp_edit_selection_tool_start (tool, display, coords,
-                                            GIMP_TRANSLATE_MODE_LAYER_MASK, TRUE);
-          }
-        else if (GIMP_IS_CHANNEL (drawable))
-          {
-            gimp_tool_control_activate (tool->control);
-            gimp_edit_selection_tool_start (tool, display, coords,
-                                            GIMP_TRANSLATE_MODE_CHANNEL, TRUE);
-          }
-        else if (GIMP_IS_LAYER (drawable))
+        if(active_item)
           {
-            gimp_tool_control_activate (tool->control);
-            gimp_edit_selection_tool_start (tool, display, coords,
-                                            GIMP_TRANSLATE_MODE_LAYER, TRUE);
+            if (GIMP_IS_LAYER_MASK (active_item))
+              {
+                locked_message = _("The active layer mask is locked from translation.");
+                if(! gimp_item_is_position_locked (active_item))
+                  {
+                    gimp_tool_control_activate (tool->control);
+                    gimp_edit_selection_tool_start (tool, display, coords,
+                                                GIMP_TRANSLATE_MODE_LAYER_MASK, TRUE);
+                    return;
+                  }
+
+              }
+            else if (GIMP_IS_CHANNEL (active_item))
+              {
+                locked_message = _("The active channel is locked from translation.");
+                if(! gimp_item_is_position_locked (active_item))
+                  {
+                    gimp_tool_control_activate (tool->control);
+                    gimp_edit_selection_tool_start (tool, display, coords,
+                                                GIMP_TRANSLATE_MODE_CHANNEL, TRUE);
+                    return;
+                  }
+              }
+            else if (GIMP_IS_LAYER (active_item))
+              {
+                locked_message = _("The active layer is locked from translation.");
+                if(! gimp_item_is_position_locked (active_item))
+                  {
+                    gimp_tool_control_activate (tool->control);
+                    gimp_edit_selection_tool_start (tool, display, coords,
+                                               GIMP_TRANSLATE_MODE_LAYER, TRUE);
+                    return;
+                  }
+              }
           }
+
       }
       break;
     }
+
+  if (! active_item)
+    {
+      gimp_tool_message_literal (tool, display, null_message);
+      gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
+    }
+  else
+    {
+      gimp_tool_message_literal (tool, display, locked_message);
+      gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
+    }
 }
 
 static void
@@ -685,6 +749,8 @@ gimp_move_tool_cursor_update (GimpTool         *tool,
   GimpCursorType      cursor      = GIMP_CURSOR_MOUSE;
   GimpToolCursorType  tool_cursor = GIMP_TOOL_CURSOR_MOVE;
   GimpCursorModifier  modifier    = GIMP_CURSOR_MODIFIER_NONE;
+  GimpItem           *item        = NULL;
+  gboolean            locked      = FALSE;
 
   if (options->move_type == GIMP_TRANSFORM_TYPE_PATH)
     {
@@ -693,7 +759,10 @@ gimp_move_tool_cursor_update (GimpTool         *tool,
 
       if (options->move_current)
         {
-          if (! gimp_image_get_active_vectors (image))
+          if((item = GIMP_ITEM(gimp_image_get_active_vectors (image))))
+            locked = gimp_item_is_position_locked (item);
+
+          if(!item || locked)
             modifier = GIMP_CURSOR_MODIFIER_BAD;
         }
       else
@@ -715,13 +784,19 @@ gimp_move_tool_cursor_update (GimpTool         *tool,
       tool_cursor = GIMP_TOOL_CURSOR_RECT_SELECT;
       modifier    = GIMP_CURSOR_MODIFIER_MOVE;
 
+
       if (gimp_channel_is_empty (gimp_image_get_mask (image)))
         modifier = GIMP_CURSOR_MODIFIER_BAD;
     }
+  //Remy: if GIMP_TRANSFORM_TYPE_LAYER:
+  //Remy: move tool selected "Move the active layer"
   else if (options->move_current)
     {
-      if (! gimp_image_get_active_drawable (image))
-        modifier = GIMP_CURSOR_MODIFIER_BAD;
+      if (! (item = GIMP_ITEM(gimp_image_get_active_drawable(image))))
+          modifier = GIMP_CURSOR_MODIFIER_BAD;
+      else
+          if (gimp_item_is_position_locked (item))
+            modifier = GIMP_CURSOR_MODIFIER_BAD;
     }
   else
     {
@@ -729,6 +804,7 @@ gimp_move_tool_cursor_update (GimpTool         *tool,
       GimpLayer  *layer;
       const gint  snap_distance = display->config->snap_distance;
 
+      //Remy: If  mouse under guide
       if (gimp_display_shell_get_show_guides (shell) &&
           (guide = gimp_image_find_guide (image, coords->x, coords->y,
                                           FUNSCALEX (shell, snap_distance),
@@ -737,6 +813,7 @@ gimp_move_tool_cursor_update (GimpTool         *tool,
           tool_cursor = GIMP_TOOL_CURSOR_HAND;
           modifier    = GIMP_CURSOR_MODIFIER_MOVE;
         }
+      //Remy: If has layer under mouse
       else if ((layer = gimp_image_pick_layer (image,
                                                coords->x, coords->y)))
         {
@@ -750,11 +827,17 @@ gimp_move_tool_cursor_update (GimpTool         *tool,
           else if (layer != gimp_image_get_active_layer (image))
             {
               tool_cursor = GIMP_TOOL_CURSOR_HAND;
-              modifier    = GIMP_CURSOR_MODIFIER_MOVE;
+	      modifier    = GIMP_CURSOR_MODIFIER_MOVE;
+            }
+          //Remy: if layer lock translation:
+          else if(gimp_item_is_position_locked (GIMP_ITEM (layer)))
+            {
+              modifier = GIMP_CURSOR_MODIFIER_BAD;
             }
         }
       else
         {
+          //Remy: No drawable under mouse cursor
           modifier = GIMP_CURSOR_MODIFIER_BAD;
         }
     }
diff --git a/app/tools/gimptransformtool.c b/app/tools/gimptransformtool.c
index 8e33c31..06bd4b5 100644
--- a/app/tools/gimptransformtool.c
+++ b/app/tools/gimptransformtool.c
@@ -240,10 +240,11 @@ gimp_transform_tool_initialize (GimpTool     *tool,
       return FALSE;
     }
 
-  if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
+//Remy:
+  if (gimp_item_is_position_locked (GIMP_ITEM (drawable)))
     {
       g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
-			   _("The active layer's pixels are locked."));
+                           _("The active layer is locked from any transformations."));
       return FALSE;
     }
 
@@ -616,11 +617,11 @@ gimp_transform_tool_cursor_update (GimpTool         *tool,
 
   switch (options->type)
     {
-      GimpDrawable *drawable;
-
+      GimpDrawable *drawable = NULL;
+      GimpVectors *vector = NULL;
     case GIMP_TRANSFORM_TYPE_LAYER:
       drawable = gimp_image_get_active_drawable (image);
-      if (gimp_item_is_content_locked (GIMP_ITEM (drawable)))
+      if (gimp_item_is_position_locked (GIMP_ITEM (drawable)))
         modifier = GIMP_CURSOR_MODIFIER_BAD;
       break;
 
@@ -628,8 +629,11 @@ gimp_transform_tool_cursor_update (GimpTool         *tool,
       break;
 
     case GIMP_TRANSFORM_TYPE_PATH:
-      if (! gimp_image_get_active_vectors (image))
+      if (!(vector = gimp_image_get_active_vectors (image)))
         modifier = GIMP_CURSOR_MODIFIER_BAD;
+      else
+        if(gimp_item_is_position_locked (GIMP_ITEM (vector)))
+          modifier = GIMP_CURSOR_MODIFIER_BAD;
       break;
     }
 
@@ -1056,10 +1060,11 @@ gimp_transform_tool_transform (GimpTransformTool *tr_tool,
 
   switch (options->type)
     {
+
     case GIMP_TRANSFORM_TYPE_LAYER:
       active_item = GIMP_ITEM (gimp_image_get_active_drawable (image));
       null_message   = _("There is no layer to transform.");
-      locked_message = _("The active layer's pixels are locked.");
+      locked_message = _("The active layer is locked from transform.");
       break;
 
     case GIMP_TRANSFORM_TYPE_SELECTION:
@@ -1083,7 +1088,7 @@ gimp_transform_tool_transform (GimpTransformTool *tr_tool,
       return;
     }
 
-  if (gimp_item_is_content_locked (active_item))
+  if (gimp_item_is_position_locked (active_item))
     {
       gimp_tool_message_literal (tool, display, locked_message);
       gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
diff --git a/app/tools/gimpvectortool.c b/app/tools/gimpvectortool.c
index e18d07f..4eeed52 100644
--- a/app/tools/gimpvectortool.c
+++ b/app/tools/gimpvectortool.c
@@ -243,7 +243,8 @@ gimp_vector_tool_control (GimpTool       *tool,
 static gboolean
 gimp_vector_tool_check_writable (GimpVectorTool *vector_tool)
 {
-  if (gimp_item_is_content_locked (GIMP_ITEM (vector_tool->vectors)))
+  if (gimp_item_is_content_locked (GIMP_ITEM (vector_tool->vectors)) ||
+                            gimp_item_is_position_locked(GIMP_ITEM (vector_tool->vectors)))
     {
       gimp_tool_message_literal (GIMP_TOOL (vector_tool),
                                  GIMP_TOOL (vector_tool)->display,
diff --git a/app/widgets/gimpdrawabletreeview.c b/app/widgets/gimpdrawabletreeview.c
index 5dc9935..ad33c4e 100644
--- a/app/widgets/gimpdrawabletreeview.c
+++ b/app/widgets/gimpdrawabletreeview.c
@@ -120,6 +120,9 @@ gimp_drawable_tree_view_class_init (GimpDrawableTreeViewClass *klass)
 
   item_view_class->lock_content_stock_id = GIMP_STOCK_TOOL_PAINTBRUSH;
   item_view_class->lock_content_tooltip  = _("Lock pixels");
+
+  item_view_class->lock_position_stock_id = GIMP_STOCK_TOOL_MOVE;
+  item_view_class->lock_position_tooltip  = _("Lock  translation and transformation");
 }
 
 static void
@@ -187,7 +190,7 @@ gimp_drawable_tree_view_select_item (GimpContainerView *view,
 
 
 /*  GimpContainerTreeView methods  */
-
+//Remy! add check for lock  position! 
 static gboolean
 gimp_drawable_tree_view_drop_possible (GimpContainerTreeView   *tree_view,
                                        GimpDndType              src_type,
diff --git a/app/widgets/gimphelp-ids.h b/app/widgets/gimphelp-ids.h
index e6f5132..98a785f 100644
--- a/app/widgets/gimphelp-ids.h
+++ b/app/widgets/gimphelp-ids.h
@@ -138,6 +138,7 @@
 #define GIMP_HELP_LAYER_DIALOG_PAINT_MODE_MENU    "gimp-layer-dialog-paint-mode-menu"
 #define GIMP_HELP_LAYER_DIALOG_OPACITY_SCALE      "gimp-layer-dialog-opacity-scale"
 #define GIMP_HELP_LAYER_DIALOG_LOCK_ALPHA_BUTTON  "gimp-layer-dialog-lock-alpha-button"
+#define GIMP_HELP_LAYER_DIALOG_LOCK_POSITION_BUTTON "gimp-layer-dialog-lock-position-button"
 
 #define GIMP_HELP_LAYER_NEW                       "gimp-layer-new"
 #define GIMP_HELP_LAYER_NEW_FROM_VISIBLE          "gimp-layer-new-from-visible"
@@ -165,6 +166,7 @@
 #define GIMP_HELP_LAYER_OPACITY                   "gimp-layer-opacity"
 #define GIMP_HELP_LAYER_MODE                      "gimp-layer-mode"
 #define GIMP_HELP_LAYER_LOCK_ALPHA                "gimp-layer-lock-alpha"
+#define GIMP_HELP_LAYER_LOCK_POSITION             "gimp-layer-lock-position"
 #define GIMP_HELP_LAYER_MASK_ADD                  "gimp-layer-mask-add"
 #define GIMP_HELP_LAYER_MASK_APPLY                "gimp-layer-mask-apply"
 #define GIMP_HELP_LAYER_MASK_DELETE               "gimp-layer-mask-delete"
diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c
index 7400e0e..4bb87cf 100644
--- a/app/widgets/gimpitemtreeview.c
+++ b/app/widgets/gimpitemtreeview.c
@@ -74,6 +74,7 @@ struct _GimpItemTreeViewPriv
   GtkWidget       *lock_box;
 
   GtkWidget       *lock_content_toggle;
+  GtkWidget       *lock_position_toggle;
 
   GtkWidget       *edit_button;
   GtkWidget       *new_button;
@@ -91,6 +92,7 @@ struct _GimpItemTreeViewPriv
   GimpTreeHandler *visible_changed_handler;
   GimpTreeHandler *linked_changed_handler;
   GimpTreeHandler *lock_content_changed_handler;
+  GimpTreeHandler *lock_position_changed_handler;
 
   gboolean         inserting_item; /* EEK */
 };
@@ -169,6 +171,8 @@ static void   gimp_item_tree_view_linked_changed       (GimpItem          *item,
                                                         GimpItemTreeView  *view);
 static void   gimp_item_tree_view_lock_content_changed (GimpItem          *item,
                                                         GimpItemTreeView  *view);
+static void   gimp_item_tree_view_lock_position_changed(GimpItem          *item,
+                                                        GimpItemTreeView  *view);
 
 static void   gimp_item_tree_view_eye_clicked       (GtkCellRendererToggle *toggle,
                                                      gchar             *path,
@@ -181,7 +185,9 @@ static void   gimp_item_tree_view_chain_clicked     (GtkCellRendererToggle *togg
 static void   gimp_item_tree_view_lock_content_toggled
                                                     (GtkWidget         *widget,
                                                      GimpItemTreeView  *view);
-
+static void   gimp_item_tree_view_lock_position_toggled
+                                                    (GtkWidget         *widget,
+                                                     GimpItemTreeView  *view);
 static void   gimp_item_tree_view_update_options    (GimpItemTreeView  *view,
                                                      GimpItem          *item);
 
@@ -271,6 +277,10 @@ gimp_item_tree_view_class_init (GimpItemTreeViewClass *klass)
   klass->lock_content_tooltip    = NULL;
   klass->lock_content_help_id    = NULL;
 
+  klass->lock_position_stock_id   = NULL;
+  klass->lock_position_tooltip    = NULL;
+  klass->lock_position_help_id    = NULL;
+
   g_type_class_add_private (klass, sizeof (GimpItemTreeViewPriv));
 }
 
@@ -452,10 +462,11 @@ gimp_item_tree_view_constructed (GObject *object)
                                   item_view_class->item_type);
 
 
-  /*  Lock content toggle  */
+
 
   hbox = gimp_item_tree_view_get_lock_box (item_view);
 
+  /*  Lock content toggle  */
   item_view->priv->lock_content_toggle = gtk_toggle_button_new ();
   gtk_box_pack_start (GTK_BOX (hbox), item_view->priv->lock_content_toggle,
                       FALSE, FALSE, 0);
@@ -480,6 +491,25 @@ gimp_item_tree_view_constructed (GObject *object)
   gtk_container_add (GTK_CONTAINER (item_view->priv->lock_content_toggle),
                      image);
   gtk_widget_show (image);
+
+  /*  Lock position toggle  */
+  item_view->priv->lock_position_toggle = gtk_toggle_button_new ();
+  gtk_box_pack_start (GTK_BOX (hbox), item_view->priv->lock_position_toggle,
+                      FALSE, FALSE, 0);
+  gtk_widget_show (item_view->priv->lock_position_toggle);
+
+  g_signal_connect (item_view->priv->lock_position_toggle, "toggled",
+                    G_CALLBACK (gimp_item_tree_view_lock_position_toggled),
+                    item_view);
+  gimp_help_set_help_data (item_view->priv->lock_position_toggle,
+                           item_view_class->lock_position_tooltip,
+                           item_view_class->lock_position_help_id);
+
+  image = gtk_image_new_from_stock (item_view_class->lock_position_stock_id,
+                                    icon_size);
+  gtk_container_add (GTK_CONTAINER (item_view->priv->lock_position_toggle),
+                     image);
+  gtk_widget_show (image);
 }
 
 static void
@@ -862,6 +892,9 @@ gimp_item_tree_view_set_container (GimpContainerView *view,
 
       gimp_tree_handler_disconnect (item_view->priv->lock_content_changed_handler);
       item_view->priv->lock_content_changed_handler = NULL;
+
+      gimp_tree_handler_disconnect (item_view->priv->lock_position_changed_handler);
+      item_view->priv->lock_position_changed_handler = NULL;
     }
 
   parent_view_iface->set_container (view, container);
@@ -882,6 +915,10 @@ gimp_item_tree_view_set_container (GimpContainerView *view,
         gimp_tree_handler_connect (container, "lock-content-changed",
                                    G_CALLBACK (gimp_item_tree_view_lock_content_changed),
                                    view);
+      item_view->priv->lock_position_changed_handler =
+        gimp_tree_handler_connect (container, "lock-position-changed",
+                                   G_CALLBACK (gimp_item_tree_view_lock_position_changed),
+                                   view);
     }
 }
 
@@ -1393,6 +1430,70 @@ gimp_item_tree_view_lock_content_toggled (GtkWidget         *widget,
     }
 }
 
+
+
+/*
+* Lock position callbacks
+*  Remy!
+*  merge gimp_item_tree_view_lock_position_changed+gimp_item_tree_view_lock_content_changed=gimp_item_tree_view_lock_changed;
+*/
+static void
+gimp_item_tree_view_lock_position_changed (GimpItem         *item,
+                                          GimpItemTreeView *view)
+{
+  GimpImage *image = view->priv->image;
+  GimpItem  *active_item;
+
+  active_item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
+
+  if (active_item == item)
+    gimp_item_tree_view_update_options (view, item);
+
+}
+
+static void
+gimp_item_tree_view_lock_position_toggled (GtkWidget         *widget,
+                                          GimpItemTreeView  *view)
+{
+  GimpImage *image = view->priv->image;
+  GimpItem  *item;
+
+  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
+
+  if (item)
+    {
+      gboolean lock_position;
+
+      lock_position = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+
+      if (gimp_item_get_lock_position (item) != lock_position)
+        {
+          GimpUndo *undo;
+          gboolean  push_undo = TRUE;
+
+          /*  compress lock position undos  */
+          undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
+                                                    GIMP_UNDO_ITEM_LOCK_POSITION);
+
+          if (undo && GIMP_ITEM_UNDO (undo)->item == item)
+            push_undo = FALSE;
+
+/* Remy? Or use block() with signal_handler like in gimplayertreeview...??? */
+          g_signal_handlers_block_by_func (item,
+                                           gimp_item_tree_view_lock_position_changed,
+                                           view);
+
+          gimp_item_set_lock_position (item, lock_position, push_undo);
+
+          g_signal_handlers_unblock_by_func (item,
+                                             gimp_item_tree_view_lock_position_changed,
+                                             view);
+
+          gimp_image_flush (image);
+        }
+    }
+}
+
 static gboolean
 gimp_item_tree_view_item_pre_clicked (GimpCellRendererViewable *cell,
                                       const gchar              *path_str,
@@ -1407,7 +1508,7 @@ gimp_item_tree_view_item_pre_clicked (GimpCellRendererViewable *cell,
   path = gtk_tree_path_new_from_string (path_str);
 
   if (gtk_tree_model_get_iter (tree_view->model, &iter, path) &&
-      state & GDK_MOD1_MASK)
+      (state & GDK_MOD1_MASK))
     {
       GimpImage        *image    = gimp_item_tree_view_get_image (item_view);
       GimpViewRenderer *renderer = NULL;
@@ -1456,8 +1557,26 @@ gimp_item_tree_view_update_options (GimpItemTreeView *view,
                                          view);
     }
 
+  if (gimp_item_get_lock_position (item) !=
+      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view->priv->lock_position_toggle)))
+    {
+      g_signal_handlers_block_by_func (view->priv->lock_position_toggle,
+                                       gimp_item_tree_view_lock_position_toggled,
+                                       view);
+
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view->priv->lock_position_toggle),
+                                    gimp_item_get_lock_position (item));
+
+      g_signal_handlers_unblock_by_func (view->priv->lock_position_toggle,
+                                         gimp_item_tree_view_lock_position_toggled,
+                                         view);
+    }
+
   gtk_widget_set_sensitive (view->priv->lock_content_toggle,
                             gimp_item_can_lock_content (item));
+
+  gtk_widget_set_sensitive (view->priv->lock_position_toggle,
+                            gimp_item_can_lock_position (item));
 }
 
 
diff --git a/app/widgets/gimpitemtreeview.h b/app/widgets/gimpitemtreeview.h
index f9ab1b1..7a4508f 100644
--- a/app/widgets/gimpitemtreeview.h
+++ b/app/widgets/gimpitemtreeview.h
@@ -95,6 +95,12 @@ struct _GimpItemTreeViewClass
   const gchar          *lock_content_stock_id;
   const gchar          *lock_content_tooltip;
   const gchar          *lock_content_help_id;
+
+  /* lock position (translation and transformation) button appearance */
+  const gchar          *lock_position_stock_id;
+  const gchar          *lock_position_tooltip;
+  const gchar          *lock_position_help_id;
+
 };
 
 
diff --git a/app/widgets/gimplayertreeview.c b/app/widgets/gimplayertreeview.c
index e76809a..d09eaf5 100644
--- a/app/widgets/gimplayertreeview.c
+++ b/app/widgets/gimplayertreeview.c
@@ -66,6 +66,7 @@ struct _GimpLayerTreeViewPriv
   GtkWidget       *paint_mode_menu;
   GtkAdjustment   *opacity_adjustment;
   GtkWidget       *lock_alpha_toggle;
+  GtkWidget       *lock_full_toggle;
 
   gint             model_column_mask;
   gint             model_column_mask_visible;
@@ -291,10 +292,15 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view)
                     G_CALLBACK (gimp_layer_tree_view_opacity_scale_changed),
                     view);
 
-  /*  Lock alpha toggle  */
+
+  gtk_widget_style_get (GTK_WIDGET (view),
+                        "button-icon-size", &icon_size,
+                        NULL);
 
   hbox = gimp_item_tree_view_get_lock_box (GIMP_ITEM_TREE_VIEW (view));
 
+  /*  Lock alpha toggle  */
+
   view->priv->lock_alpha_toggle = gtk_toggle_button_new ();
   gtk_box_pack_start (GTK_BOX (hbox), view->priv->lock_alpha_toggle,
                       FALSE, FALSE, 0);
@@ -307,14 +313,31 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view)
   gimp_help_set_help_data (view->priv->lock_alpha_toggle, _("Lock alpha channel"),
                            GIMP_HELP_LAYER_DIALOG_LOCK_ALPHA_BUTTON);
 
-  gtk_widget_style_get (GTK_WIDGET (view),
-                        "button-icon-size", &icon_size,
-                        NULL);
-
   image = gtk_image_new_from_stock (GIMP_STOCK_TRANSPARENCY, icon_size);
   gtk_container_add (GTK_CONTAINER (view->priv->lock_alpha_toggle), image);
   gtk_widget_show (image);
 
+  /* Lock all toggle */
+  view->priv->lock_full_toggle = gtk_toggle_button_new ();
+  gtk_box_pack_end (GTK_BOX (hbox), view->priv->lock_full_toggle,
+                      FALSE, FALSE, 0);
+  /*
+  gtk_widget_show (view->priv->lock_full_toggle);
+  */
+/*
+  g_signal_connect (view->priv->lock_alpha_toggle, "toggled",
+                    G_CALLBACK (gimp_layer_tree_view_lock_alpha_button_toggled),
+                    view);
+
+  gimp_help_set_help_data (view->priv->lock_alpha_toggle, _("Lock alpha channel"),
+                           GIMP_HELP_LAYER_DIALOG_LOCK_ALPHA_BUTTON);
+*/
+
+
+  image = gtk_image_new_from_stock (GIMP_STOCK_LOCK, icon_size);
+  gtk_container_add (GTK_CONTAINER (view->priv->lock_full_toggle), image);
+  gtk_widget_show (image);
+
   view->priv->italic_attrs = pango_attr_list_new ();
   attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
   attr->start_index = 0;
@@ -431,6 +454,8 @@ gimp_layer_tree_view_set_container (GimpContainerView *view,
       gimp_tree_handler_disconnect (layer_view->priv->lock_alpha_changed_handler);
       layer_view->priv->lock_alpha_changed_handler = NULL;
 
+
+
       gimp_tree_handler_disconnect (layer_view->priv->mask_changed_handler);
       layer_view->priv->mask_changed_handler = NULL;
 
@@ -954,6 +979,7 @@ gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget         *widget,
     }
 }
 
+
 static void
 gimp_layer_tree_view_lock_alpha_button_toggled (GtkWidget         *widget,
                                                 GimpLayerTreeView *view)
@@ -1087,6 +1113,7 @@ gimp_layer_tree_view_update_options (GimpLayerTreeView *view,
   gtk_widget_set_sensitive (view->priv->lock_alpha_toggle,
                             gimp_layer_can_lock_alpha (layer));
 
+
   if (gimp_layer_get_opacity (layer) * 100.0 !=
       gtk_adjustment_get_value (view->priv->opacity_adjustment))
     {
diff --git a/app/widgets/gimpvectorstreeview.c b/app/widgets/gimpvectorstreeview.c
index ae4da93..52365d3 100644
--- a/app/widgets/gimpvectorstreeview.c
+++ b/app/widgets/gimpvectorstreeview.c
@@ -109,6 +109,8 @@ gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass)
   iv_class->delete_action         = "vectors-delete";
   iv_class->lock_content_stock_id = GIMP_STOCK_TOOL_PATH;
   iv_class->lock_content_tooltip  = _("Lock path strokes");
+  iv_class->lock_position_stock_id= GIMP_STOCK_TOOL_MOVE;
+  iv_class->lock_position_tooltip  = _("Lock path position");
 }
 
 static void
diff --git a/app/xcf/xcf-load.c b/app/xcf/xcf-load.c
index 23593c6..e794f91 100644
--- a/app/xcf/xcf-load.c
+++ b/app/xcf/xcf-load.c
@@ -773,6 +773,17 @@ xcf_load_layer_props (XcfInfo    *info,
           }
           break;
 
+        case PROP_LOCK_POSITION:
+          {
+            gboolean lock_position;
+
+            info->cp += xcf_read_int32 (info->fp, (guint32 *) &lock_position, 1);
+
+            if (gimp_item_can_lock_position (*layer))
+              gimp_item_set_lock_position (*layer, lock_position, FALSE);
+          }
+          break;
+
         case PROP_APPLY_MASK:
           info->cp += xcf_read_int32 (info->fp, (guint32 *) apply_mask, 1);
           break;
@@ -977,6 +988,16 @@ xcf_load_channel_props (XcfInfo      *info,
           }
           break;
 
+        case PROP_LOCK_POSITION:
+          {
+            gboolean lock_position;
+
+            info->cp += xcf_read_int32 (info->fp, (guint32 *) &lock_position, 1);
+            gimp_item_set_lock_position (GIMP_ITEM (*channel),
+                                         lock_position ? TRUE : FALSE, FALSE);
+          }
+          break;
+
         case PROP_SHOW_MASKED:
           {
             gboolean show_masked;
diff --git a/app/xcf/xcf-private.h b/app/xcf/xcf-private.h
index 33076d4..283f949 100644
--- a/app/xcf/xcf-private.h
+++ b/app/xcf/xcf-private.h
@@ -52,7 +52,8 @@ typedef enum
   PROP_LOCK_CONTENT       = 28,
   PROP_GROUP_ITEM         = 29,
   PROP_ITEM_PATH          = 30,
-  PROP_GROUP_ITEM_FLAGS   = 31
+  PROP_GROUP_ITEM_FLAGS   = 31,
+  PROP_LOCK_POSITION      = 32
 } PropType;
 
 typedef enum
diff --git a/app/xcf/xcf-save.c b/app/xcf/xcf-save.c
index 44e4785..fd38396 100644
--- a/app/xcf/xcf-save.c
+++ b/app/xcf/xcf-save.c
@@ -493,6 +493,8 @@ xcf_save_layer_props (XcfInfo    *info,
                                   gimp_item_get_lock_content (GIMP_ITEM (layer))));
   xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_ALPHA, error,
                                   gimp_layer_get_lock_alpha (layer)));
+  xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_POSITION, error,
+                                  gimp_item_get_lock_position (layer)));
 
   if (gimp_layer_get_mask (layer))
     {
@@ -585,6 +587,8 @@ xcf_save_channel_props (XcfInfo      *info,
                                   gimp_item_get_linked (GIMP_ITEM (channel))));
   xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_CONTENT, error,
                                   gimp_item_get_lock_content (GIMP_ITEM (channel))));
+  xcf_check_error (xcf_save_prop (info, image, PROP_LOCK_POSITION, error,
+                                  gimp_item_get_lock_position (GIMP_ITEM (channel))));
   xcf_check_error (xcf_save_prop (info, image, PROP_SHOW_MASKED, error,
                                   gimp_channel_get_show_masked (channel)));
 
@@ -752,6 +756,19 @@ xcf_save_prop (XcfInfo    *info,
       }
       break;
 
+    case PROP_LOCK_POSITION:
+      {
+        guint32 lock_position;
+
+        lock_position = va_arg (args, guint32);
+        size = 4;
+
+        xcf_write_prop_type_check_error (info, prop_type);
+        xcf_write_int32_check_error (info, &size, 1);
+        xcf_write_int32_check_error (info, &lock_position, 1);
+      }
+      break;
+
     case PROP_APPLY_MASK:
       {
         guint32 apply_mask;
diff --git a/libgimpwidgets/gimpstock.c b/libgimpwidgets/gimpstock.c
index 4e6b5ab..d45fbf8 100644
--- a/libgimpwidgets/gimpstock.c
+++ b/libgimpwidgets/gimpstock.c
@@ -134,6 +134,8 @@ static const GtkStockItem gimp_stock_items[] =
   { GIMP_STOCK_RESET,          N_("_Reset"),          0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_VISIBLE,        N_("Visible"),         0, 0, LIBGIMP_DOMAIN },
 
+  { GIMP_STOCK_LOCK,                          NULL,   0, 0, LIBGIMP_DOMAIN },
+  { GIMP_STOCK_UNLOCK,                        NULL,   0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_GRADIENT_LINEAR,               NULL,   0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_GRADIENT_BILINEAR,             NULL,   0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_GRADIENT_RADIAL,               NULL,   0, 0, LIBGIMP_DOMAIN },
@@ -452,6 +454,8 @@ gimp_stock_button_pixbufs[] =
 
   { GIMP_STOCK_LINKED,                   stock_linked_20                   },
   { GIMP_STOCK_VISIBLE,                  stock_eye_20                      },
+  { GIMP_STOCK_LOCK,                     stock_lock_16                     },
+  { GIMP_STOCK_UNLOCK,                   stock_unlock_16                   },
 
   { GIMP_STOCK_MOVE_TO_SCREEN,           stock_move_to_screen_24           },
 
@@ -585,6 +589,8 @@ gimp_stock_menu_pixbufs[] =
 
   { GIMP_STOCK_LINKED,                   stock_linked_12                   },
   { GIMP_STOCK_VISIBLE,                  stock_eye_12                      },
+  { GIMP_STOCK_LOCK,                     stock_lock_16                     },
+  { GIMP_STOCK_UNLOCK,                   stock_unlock_16                   },
 
   { GIMP_STOCK_SELECTION_ALL,            stock_selection_all_16            },
   { GIMP_STOCK_SELECTION_NONE,           stock_selection_none_16           },
diff --git a/libgimpwidgets/gimpstock.h b/libgimpwidgets/gimpstock.h
index cdb4423..601518b 100644
--- a/libgimpwidgets/gimpstock.h
+++ b/libgimpwidgets/gimpstock.h
@@ -42,6 +42,8 @@ G_BEGIN_DECLS
 #define GIMP_STOCK_PASTE_INTO               "gimp-paste-into"
 #define GIMP_STOCK_RESET                    "gimp-reset"
 #define GIMP_STOCK_VISIBLE                  "gimp-visible"
+#define GIMP_STOCK_LOCK                     "gimp-lock"
+#define GIMP_STOCK_UNLOCK                   "gimp-unlock"
 
 #define GIMP_STOCK_GRADIENT_LINEAR               "gimp-gradient-linear"
 #define GIMP_STOCK_GRADIENT_BILINEAR             "gimp-gradient-bilinear"
diff --git a/themes/Default/images/Makefile.am b/themes/Default/images/Makefile.am
index bf854d2..30a3703 100644
--- a/themes/Default/images/Makefile.am
+++ b/themes/Default/images/Makefile.am
@@ -222,7 +222,9 @@ STOCK_BUTTON_IMAGES = \
 	stock-video-24.png			\
 	stock-warning-24.png			\
 	stock-web-24.png			\
-	stock-wilber-22.png
+	stock-wilber-22.png			\
+	stock-lock-16.png			\
+	stock-unlock-16.png
 
 STOCK_DND_IMAGES = \
 	stock-channel-32.png			\
diff --git a/themes/Default/images/stock-lock-16.png b/themes/Default/images/stock-lock-16.png
new file mode 100644
index 0000000..f6e0057
Binary files /dev/null and b/themes/Default/images/stock-lock-16.png differ
diff --git a/themes/Default/images/stock-unlock-16.png b/themes/Default/images/stock-unlock-16.png
new file mode 100644
index 0000000..4a61a48
Binary files /dev/null and b/themes/Default/images/stock-unlock-16.png differ
