diff --git a/ChangeLog b/ChangeLog
index fc7883d6f7..da1dcde2e1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,91 @@
+2004-05-12  Michael Natterer  <mitch@gimp.org>
+
+	* app/actions/documents-actions.c
+	* app/actions/documents-commands.c
+	* app/actions/edit-actions.c
+	* app/actions/edit-commands.[ch]
+	* app/actions/layers-actions.c
+	* app/actions/layers-commands.c
+	* app/actions/select-actions.c
+	* app/actions/select-commands.[ch]
+	* app/actions/vectors-actions.c
+	* app/actions/vectors-commands.[ch]: added tooltips for actions
+	which are now used for dialog buttons, added callback
+	implementations which formerly lived in various widgets, moved
+	some actions around and did some general cleanups.
+
+	* menus/image-menu.xml.in: s/edit-stroke/select-stroke/
+
+	* menus/Makefile.am
+	* menus/selection-editor-menu.xml: new popup menu.
+
+	* app/menus/menus.c: register <SelectionEditor> and <UndoEditor>
+	UI managers.
+
+	* app/widgets/gimpeditor.[ch]: added construct properties
+	"menu-factory", "menu-identifier", "ui-path" and "popup-data".
+	Implement GObject::constructor() and create the UI manager
+	if all needed properties were set. Enables creating action
+	buttons at widget construction time because they need a
+	UI manager.
+
+	(gimp_editor_add_action_button): extended to take a va_list of
+	"extended" actions which are invoked if the resp. button emits
+	"extended_clicked". Store the actions and their modifier masks in
+	a list attached to the button.
+
+	* app/widgets/gimpcontainerview.c
+	(gimp_container_view_item_selected): if the view has container
+	*and* context, simply change the context and return.
+
+	(gimp_container_view_context_changed): don't emit "select_item"
+	manually but simply call gimp_container_view_select_item().
+
+	(gimp_container_view_viewable_dropped): use
+	gimp_container_view_item_selected() instead of changing the
+	context directly.
+
+	* app/widgets/gimpcontainereditor.c
+	(gimp_container_editor_select_item): update the UI manager.
+
+	* app/widgets/gimpdockable.c: don't try to fiddle with the
+	dialog's menu if it doesn't have a ui_path (happens if the UI
+	manager is just a collection of actions for the dialog buttons and
+	has no menu registered).
+
+	* app/widgets/gimpimageeditor.c: connect to the image's "flush"
+	signal and update the UI manager in the callback.
+
+	* app/widgets/gimpitemtreeview.c: use GimpEditor's construct
+	properties to create the UI manager so GimpItemTreeView subclasses
+	can have action buttons. Update the UI manager in
+	gimp_item_tree_view_select_item().
+
+	* app/widgets/gimpbufferview.c
+	* app/widgets/gimpcolormapeditor.c
+	* app/widgets/gimpcontainergridview.c
+	* app/widgets/gimpdatafactoryview.c
+	* app/widgets/gimpfontview.c
+	* app/widgets/gimpimageview.c
+	* app/widgets/gimptemplateview.c
+	* app/widgets/gimptoolview.c: changed calls to
+	gimp_editor_add_action_button() accordingly and removed some
+	unneeded select_item() implementations.
+
+	* app/widgets/gimpchanneltreeview.c
+	* app/widgets/gimpvectorstreeview.[ch]
+	* app/widgets/gimpdocumentview.[ch]
+	* app/widgets/gimplayertreeview.c
+	* app/widgets/gimpselectioneditor.[ch]
+	* app/widgets/gimpundoeditor.[ch]: use action buttons and removed
+	lots of callbacks which went to the resp. action callbacks.
+
+	* app/widgets/widgets-types.h: removed some now unneeded function
+	prototypes.
+
+	* app/gui/dialogs-constructors.c: changed (simplified) many dialog
+	constructors accordingly.
+
 2004-05-12  Sven Neumann  <sven@gimp.org>
 
 	* libgimpwidgets/gimpwidgets.c (gimp_scale_entry_new_internal)
diff --git a/app/actions/documents-actions.c b/app/actions/documents-actions.c
index 9e9dd488ca..cf72d7a936 100644
--- a/app/actions/documents-actions.c
+++ b/app/actions/documents-actions.c
@@ -27,10 +27,9 @@
 #include "core/gimpcontext.h"
 
 #include "widgets/gimpactiongroup.h"
-#include "widgets/gimpcontainereditor.h"
-#include "widgets/gimpcontainerview.h"
 #include "widgets/gimphelp-ids.h"
 
+#include "actions.h"
 #include "documents-actions.h"
 #include "documents-commands.h"
 
@@ -43,7 +42,8 @@ static GimpActionEntry documents_actions[] =
     GIMP_HELP_DOCUMENT_DIALOG },
 
   { "documents-open", GTK_STOCK_OPEN,
-    N_("_Open Image"), "", NULL,
+    N_("_Open Image"), "",
+    N_("Open the selected entry"),
     G_CALLBACK (documents_open_document_cmd_callback),
     GIMP_HELP_DOCUMENT_OPEN },
 
@@ -58,12 +58,14 @@ static GimpActionEntry documents_actions[] =
     GIMP_HELP_DOCUMENT_OPEN },
 
   { "documents-remove", GTK_STOCK_REMOVE,
-    N_("Remove _Entry"), "", NULL,
+    N_("Remove _Entry"), "",
+    N_("Remove the selected entry"),
     G_CALLBACK (documents_remove_document_cmd_callback),
     GIMP_HELP_DOCUMENT_REMOVE },
 
   { "documents-recreate-preview", GTK_STOCK_REFRESH,
-    N_("Recreate _Preview"), "", NULL,
+    N_("Recreate _Preview"), "",
+    N_("Recreate preview"),
     G_CALLBACK (documents_recreate_preview_cmd_callback),
     GIMP_HELP_DOCUMENT_REFRESH },
 
@@ -91,14 +93,13 @@ void
 documents_actions_update (GimpActionGroup *group,
                           gpointer         data)
 {
-  GimpContainerEditor *editor;
-  GimpContext         *context;
-  GimpImagefile       *imagefile;
+  GimpContext   *context;
+  GimpImagefile *imagefile = NULL;
 
-  editor  = GIMP_CONTAINER_EDITOR (data);
-  context = gimp_container_view_get_context (editor->view);
+  context = action_data_get_context (data);
 
-  imagefile = gimp_context_get_imagefile (context);
+  if (context)
+    imagefile = gimp_context_get_imagefile (context);
 
 #define SET_SENSITIVE(action,condition) \
         gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
diff --git a/app/actions/documents-commands.c b/app/actions/documents-commands.c
index 86bd552047..d957aaaebc 100644
--- a/app/actions/documents-commands.c
+++ b/app/actions/documents-commands.c
@@ -18,15 +18,39 @@
 
 #include "config.h"
 
+#include <string.h>
+
 #include <gtk/gtk.h>
 
+#include "libgimpthumb/gimpthumb.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "actions-types.h"
 
+#include "core/gimp.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpcontext.h"
+#include "core/gimpimagefile.h"
+
+#include "file/file-open.h"
+#include "file/file-utils.h"
+
+#include "widgets/gimpcontainerview.h"
 #include "widgets/gimpdocumentview.h"
 
+#include "display/gimpdisplay.h"
+#include "display/gimpdisplay-foreach.h"
+
 #include "documents-commands.h"
+#include "file-commands.h"
+
+#include "gimp-intl.h"
+
+
+/*  local function prototypes  */
+
+static void   documents_open_image (GimpContext   *context,
+                                    GimpImagefile *imagefile);
 
 
 /*  public functions */
@@ -35,66 +59,213 @@ void
 documents_open_document_cmd_callback (GtkAction *action,
                                       gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpContainer       *container;
+  GimpImagefile       *imagefile;
 
-  gtk_button_clicked (GTK_BUTTON (view->open_button));
+  context   = gimp_container_view_get_context (editor->view);
+  container = gimp_container_view_get_container (editor->view);
+
+  imagefile = gimp_context_get_imagefile (context);
+
+  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
+    {
+      documents_open_image (context, imagefile);
+    }
+  else
+    {
+      file_file_open_dialog (context->gimp, NULL, GTK_WIDGET (editor));
+    }
+}
+
+typedef struct _RaiseClosure RaiseClosure;
+
+struct _RaiseClosure
+{
+  const gchar *name;
+  gboolean     found;
+};
+
+static void
+documents_raise_display (gpointer data,
+                         gpointer user_data)
+{
+  GimpDisplay  *gdisp   = (GimpDisplay *) data;
+  RaiseClosure *closure = (RaiseClosure *) user_data;
+  const gchar  *uri;
+
+  uri = gimp_object_get_name (GIMP_OBJECT (gdisp->gimage));
+
+  if (uri && ! strcmp (closure->name, uri))
+    {
+      closure->found = TRUE;
+      gtk_window_present (GTK_WINDOW (gdisp->shell));
+    }
 }
 
 void
 documents_raise_or_open_document_cmd_callback (GtkAction *action,
                                                gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpContainer       *container;
+  GimpImagefile       *imagefile;
 
-  gimp_button_extended_clicked (GIMP_BUTTON (view->open_button),
-                                GDK_SHIFT_MASK);
+  context   = gimp_container_view_get_context (editor->view);
+  container = gimp_container_view_get_container (editor->view);
+
+  imagefile = gimp_context_get_imagefile (context);
+
+  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
+    {
+      RaiseClosure closure;
+
+      closure.name  = gimp_object_get_name (GIMP_OBJECT (imagefile));
+      closure.found = FALSE;
+
+      gimp_container_foreach (context->gimp->displays,
+                              documents_raise_display,
+                              &closure);
+
+      if (! closure.found)
+        documents_open_image (context, imagefile);
+    }
 }
 
 void
 documents_file_open_dialog_cmd_callback (GtkAction *action,
                                          gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpContainer       *container;
+  GimpImagefile       *imagefile;
 
-  gimp_button_extended_clicked (GIMP_BUTTON (view->open_button),
-                                GDK_CONTROL_MASK);
+  context   = gimp_container_view_get_context (editor->view);
+  container = gimp_container_view_get_container (editor->view);
+
+  imagefile = gimp_context_get_imagefile (context);
+
+  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
+    {
+      file_file_open_dialog (context->gimp,
+                             gimp_object_get_name (GIMP_OBJECT (imagefile)),
+                             GTK_WIDGET (editor));
+    }
 }
 
 void
 documents_remove_document_cmd_callback (GtkAction *action,
                                         gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpContainer       *container;
+  GimpImagefile       *imagefile;
 
-  gtk_button_clicked (GTK_BUTTON (view->remove_button));
+  context   = gimp_container_view_get_context (editor->view);
+  container = gimp_container_view_get_container (editor->view);
+
+  imagefile = gimp_context_get_imagefile (context);
+
+  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
+    {
+      gimp_container_remove (container, GIMP_OBJECT (imagefile));
+    }
 }
 
-
 void
 documents_recreate_preview_cmd_callback (GtkAction *action,
                                          gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContext         *context;
+  GimpContainer       *container;
+  GimpImagefile       *imagefile;
 
-  gtk_button_clicked (GTK_BUTTON (view->refresh_button));
+  context   = gimp_container_view_get_context (editor->view);
+  container = gimp_container_view_get_container (editor->view);
+
+  imagefile = gimp_context_get_imagefile (context);
+
+  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
+    {
+      gint preview_size;
+
+      preview_size = gimp_container_view_get_preview_size (editor->view, NULL);
+
+      gimp_imagefile_create_thumbnail (imagefile, context, preview_size);
+    }
 }
 
 void
 documents_reload_previews_cmd_callback (GtkAction *action,
                                         gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContainer       *container;
 
-  gimp_button_extended_clicked (GIMP_BUTTON (view->refresh_button),
-                                GDK_SHIFT_MASK);
+  container = gimp_container_view_get_container (editor->view);
+
+  gimp_container_foreach (container,
+                          (GFunc) gimp_imagefile_update,
+                          editor->view);
+}
+
+static void
+documents_delete_dangling_foreach (GimpImagefile *imagefile,
+                                   GimpContainer *container)
+{
+  if (gimp_thumbnail_peek_image (imagefile->thumbnail) ==
+      GIMP_THUMB_STATE_NOT_FOUND)
+    {
+      gimp_container_remove (container, GIMP_OBJECT (imagefile));
+    }
 }
 
 void
 documents_delete_dangling_documents_cmd_callback (GtkAction *action,
                                                   gpointer   data)
 {
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (data);
+  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
+  GimpContainer       *container;
 
-  gimp_button_extended_clicked (GIMP_BUTTON (view->refresh_button),
-                                GDK_CONTROL_MASK);
+  container = gimp_container_view_get_container (editor->view);
+
+  gimp_container_foreach (container,
+                          (GFunc) documents_delete_dangling_foreach,
+                          container);
+}
+
+
+/*  private functions  */
+
+static void
+documents_open_image (GimpContext   *context,
+                      GimpImagefile *imagefile)
+{
+  const gchar        *uri;
+  GimpImage          *gimage;
+  GimpPDBStatusType   status;
+  GError             *error = NULL;
+
+  uri = gimp_object_get_name (GIMP_OBJECT (imagefile));
+
+  gimage = file_open_with_display (context->gimp, context,
+                                   uri, &status, &error);
+
+  if (! gimage && status != GIMP_PDB_CANCEL)
+    {
+      gchar *filename;
+
+      filename = file_utils_uri_to_utf8_filename (uri);
+
+      g_message (_("Opening '%s' failed:\n\n%s"),
+                 filename, error->message);
+      g_clear_error (&error);
+
+      g_free (filename);
+    }
 }
diff --git a/app/actions/edit-actions.c b/app/actions/edit-actions.c
index ce16996444..a294c6c259 100644
--- a/app/actions/edit-actions.c
+++ b/app/actions/edit-actions.c
@@ -64,15 +64,23 @@ static GimpActionEntry edit_actions[] =
   { "edit-buffer-menu", NULL, N_("Buffer") },
 
   { "edit-undo", GTK_STOCK_UNDO,
-    N_("_Undo"), "<control>Z", NULL,
+    N_("_Undo"), "<control>Z",
+    N_("Undo"),
     G_CALLBACK (edit_undo_cmd_callback),
     GIMP_HELP_EDIT_UNDO },
 
   { "edit-redo", GTK_STOCK_REDO,
-    N_("_Redo"), "<control>Y", NULL,
+    N_("_Redo"), "<control>Y",
+    N_("Redo"),
     G_CALLBACK (edit_redo_cmd_callback),
     GIMP_HELP_EDIT_REDO },
 
+  { "edit-undo-clear", GTK_STOCK_CLEAR,
+    N_("_Clear Undo History"), "",
+    N_("Clear undo history"),
+    G_CALLBACK (edit_undo_clear_cmd_callback),
+    GIMP_HELP_EDIT_UNDO_CLEAR },
+
   { "edit-cut", GTK_STOCK_CUT,
     N_("Cu_t"), "<control>X", NULL,
     G_CALLBACK (edit_cut_cmd_callback),
@@ -116,12 +124,7 @@ static GimpActionEntry edit_actions[] =
   { "edit-clear", GTK_STOCK_CLEAR,
     N_("Cl_ear"), "<control>K", NULL,
     G_CALLBACK (edit_clear_cmd_callback),
-    GIMP_HELP_EDIT_CLEAR },
-
-  { "edit-stroke", GIMP_STOCK_SELECTION_STROKE,
-    N_("_Stroke Selection..."), NULL, NULL,
-    G_CALLBACK (edit_stroke_cmd_callback),
-    GIMP_HELP_SELECTION_STROKE }
+    GIMP_HELP_EDIT_CLEAR }
 };
 
 static GimpEnumActionEntry edit_fill_actions[] =
@@ -205,8 +208,9 @@ edit_actions_update (GimpActionGroup *group,
         gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
 
   {
-    gchar *undo_name = NULL;
-    gchar *redo_name = NULL;
+    gchar    *undo_name = NULL;
+    gchar    *redo_name = NULL;
+    gboolean  enabled   = FALSE;
 
     if (gimage && gimp_image_undo_is_enabled (gimage))
       {
@@ -216,6 +220,8 @@ edit_actions_update (GimpActionGroup *group,
         undo = gimp_undo_stack_peek (gimage->undo_stack);
         redo = gimp_undo_stack_peek (gimage->redo_stack);
 
+        enabled = TRUE;
+
         if (undo)
           undo_name =
             g_strdup_printf (_("_Undo %s"),
@@ -230,8 +236,9 @@ edit_actions_update (GimpActionGroup *group,
     SET_LABEL ("edit-undo", undo_name ? undo_name : _("_Undo"));
     SET_LABEL ("edit-redo", redo_name ? redo_name : _("_Redo"));
 
-    SET_SENSITIVE ("edit-undo", undo_name);
-    SET_SENSITIVE ("edit-redo", redo_name);
+    SET_SENSITIVE ("edit-undo",       enabled && undo_name);
+    SET_SENSITIVE ("edit-redo",       enabled && redo_name);
+    SET_SENSITIVE ("edit-undo-clear", enabled && (redo_name || redo_name));
 
     g_free (undo_name);
     g_free (redo_name);
@@ -249,7 +256,6 @@ edit_actions_update (GimpActionGroup *group,
   SET_SENSITIVE ("edit-fill-fg",      drawable);
   SET_SENSITIVE ("edit-fill-bg",      drawable);
   SET_SENSITIVE ("edit-fill-pattern", drawable);
-  SET_SENSITIVE ("edit-stroke",       drawable && sel);
 
 #undef SET_LABEL
 #undef SET_SENSITIVE
diff --git a/app/actions/edit-commands.c b/app/actions/edit-commands.c
index 52096710d2..cd0a07be69 100644
--- a/app/actions/edit-commands.c
+++ b/app/actions/edit-commands.c
@@ -33,7 +33,6 @@
 #include "core/gimpdrawable.h"
 #include "core/gimpimage.h"
 #include "core/gimpimage-undo.h"
-#include "core/gimptoolinfo.h"
 
 #include "display/gimpdisplay.h"
 #include "display/gimpdisplayshell.h"
@@ -43,7 +42,6 @@
 #include "widgets/gimpdialogfactory.h"
 
 #include "gui/dialogs.h"
-#include "gui/stroke-dialog.h"
 
 #include "actions.h"
 #include "edit-commands.h"
@@ -85,6 +83,44 @@ edit_redo_cmd_callback (GtkAction *action,
     gimp_image_flush (gimage);
 }
 
+static void
+edit_undo_clear_callback (GtkWidget *widget,
+                          gboolean   clear,
+                          gpointer   data)
+{
+  if (clear)
+    {
+      GimpImage *gimage = data;
+
+      gimp_image_undo_disable (gimage);
+      gimp_image_undo_enable (gimage);
+      gimp_image_flush (gimage);
+    }
+}
+
+void
+edit_undo_clear_cmd_callback (GtkAction *action,
+                              gpointer   data)
+{
+  GimpImage *gimage;
+  GtkWidget *widget;
+  GtkWidget *dialog;
+  return_if_no_image (gimage, data);
+  return_if_no_widget (widget, data);
+
+  dialog = gimp_query_boolean_box (_("Clear Undo History"), widget,
+                                   gimp_standard_help_func,
+                                   GIMP_HELP_EDIT_UNDO_CLEAR,
+                                   GIMP_STOCK_QUESTION,
+                                   _("Really clear image's undo history?"),
+                                   GTK_STOCK_CLEAR, GTK_STOCK_CANCEL,
+                                   G_OBJECT (gimage),
+                                   "disconnect",
+                                   edit_undo_clear_callback,
+                                   gimage);
+  gtk_widget_show (dialog);
+}
+
 void
 edit_cut_cmd_callback (GtkAction *action,
                        gpointer   data)
@@ -245,46 +281,6 @@ edit_fill_cmd_callback (GtkAction *action,
   gimp_image_flush (gimage);
 }
 
-void
-edit_stroke_cmd_callback (GtkAction *action,
-                          gpointer   data)
-{
-  GimpImage    *gimage;
-  GimpDrawable *drawable;
-  GtkWidget    *widget;
-  return_if_no_drawable (gimage, drawable, data);
-  return_if_no_widget (widget, data);
-
-  edit_stroke_selection (GIMP_ITEM (gimp_image_get_mask (gimage)), widget);
-}
-
-void
-edit_stroke_selection (GimpItem  *item,
-                       GtkWidget *parent)
-{
-  GimpImage    *gimage;
-  GimpDrawable *active_drawable;
-  GtkWidget    *dialog;
-
-  g_return_if_fail (GIMP_IS_ITEM (item));
-  g_return_if_fail (GTK_IS_WIDGET (parent));
-
-  gimage = gimp_item_get_image (item);
-
-  active_drawable = gimp_image_active_drawable (gimage);
-
-  if (! active_drawable)
-    {
-      g_message (_("There is no active layer or channel to stroke to."));
-      return;
-    }
-
-  dialog = stroke_dialog_new (item, GIMP_STOCK_SELECTION_STROKE,
-                              GIMP_HELP_SELECTION_STROKE,
-                              parent);
-  gtk_widget_show (dialog);
-}
-
 
 /*  private functions  */
 
diff --git a/app/actions/edit-commands.h b/app/actions/edit-commands.h
index d16215c733..ef1e07c28a 100644
--- a/app/actions/edit-commands.h
+++ b/app/actions/edit-commands.h
@@ -24,6 +24,8 @@ void   edit_undo_cmd_callback         (GtkAction *action,
                                        gpointer   data);
 void   edit_redo_cmd_callback         (GtkAction *action,
                                        gpointer   data);
+void   edit_undo_clear_cmd_callback   (GtkAction *action,
+                                       gpointer   data);
 void   edit_cut_cmd_callback          (GtkAction *action,
                                        gpointer   data);
 void   edit_copy_cmd_callback         (GtkAction *action,
@@ -45,11 +47,6 @@ void   edit_clear_cmd_callback        (GtkAction *action,
 void   edit_fill_cmd_callback         (GtkAction *action,
                                        gint       value,
                                        gpointer   data);
-void   edit_stroke_cmd_callback       (GtkAction *action,
-                                       gpointer   data);
-
-void   edit_stroke_selection          (GimpItem  *item,
-                                       GtkWidget *parent);
 
 
 #endif /* __EDIT_COMMANDS_H__ */
diff --git a/app/actions/layers-actions.c b/app/actions/layers-actions.c
index bb45ff8198..0755f6e3ee 100644
--- a/app/actions/layers-actions.c
+++ b/app/actions/layers-actions.c
@@ -119,7 +119,8 @@ static GimpActionEntry layers_actions[] =
     GIMP_HELP_LAYER_LOWER_TO_BOTTOM },
 
   { "layers-anchor", GIMP_STOCK_ANCHOR,
-    N_("_Anchor Layer"), NULL, NULL,
+    N_("_Anchor Layer"), NULL,
+    N_("Anchor floating layer"),
     G_CALLBACK (layers_anchor_cmd_callback),
     GIMP_HELP_LAYER_ANCHOR },
 
diff --git a/app/actions/layers-commands.c b/app/actions/layers-commands.c
index 4ba3f49b55..d13bd52072 100644
--- a/app/actions/layers-commands.c
+++ b/app/actions/layers-commands.c
@@ -177,10 +177,10 @@ layers_raise_cmd_callback (GtkAction *action,
 			   gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  gimp_image_raise_layer (gimage, active_layer);
+  gimp_image_raise_layer (gimage, layer);
   gimp_image_flush (gimage);
 }
 
@@ -189,10 +189,10 @@ layers_lower_cmd_callback (GtkAction *action,
 			   gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  gimp_image_lower_layer (gimage, active_layer);
+  gimp_image_lower_layer (gimage, layer);
   gimp_image_flush (gimage);
 }
 
@@ -201,10 +201,10 @@ layers_raise_to_top_cmd_callback (GtkAction *action,
 				  gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  gimp_image_raise_layer_to_top (gimage, active_layer);
+  gimp_image_raise_layer_to_top (gimage, layer);
   gimp_image_flush (gimage);
 }
 
@@ -213,10 +213,10 @@ layers_lower_to_bottom_cmd_callback (GtkAction *action,
 				     gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  gimp_image_lower_layer_to_bottom (gimage, active_layer);
+  gimp_image_lower_layer_to_bottom (gimage, layer);
   gimp_image_flush (gimage);
 }
 
@@ -237,13 +237,13 @@ layers_duplicate_cmd_callback (GtkAction *action,
 			       gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   GimpLayer *new_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
 
   new_layer =
-    GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (active_layer),
-                                     G_TYPE_FROM_INSTANCE (active_layer),
+    GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (layer),
+                                     G_TYPE_FROM_INSTANCE (layer),
                                      TRUE));
   gimp_image_add_layer (gimage, new_layer, -1);
 
@@ -255,12 +255,12 @@ layers_anchor_cmd_callback (GtkAction *action,
 			    gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  if (gimp_layer_is_floating_sel (active_layer))
+  if (gimp_layer_is_floating_sel (layer))
     {
-      floating_sel_anchor (active_layer);
+      floating_sel_anchor (layer);
       gimp_image_flush (gimage);
     }
 }
@@ -270,11 +270,10 @@ layers_merge_down_cmd_callback (GtkAction *action,
 				gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  gimp_image_merge_down (gimage, active_layer,
-                         gimp_get_user_context (gimage->gimp),
+  gimp_image_merge_down (gimage, layer, action_data_get_context (data),
                          GIMP_EXPAND_AS_NECESSARY);
   gimp_image_flush (gimage);
 }
@@ -284,13 +283,13 @@ layers_delete_cmd_callback (GtkAction *action,
 			    gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  if (gimp_layer_is_floating_sel (active_layer))
-    floating_sel_remove (active_layer);
+  if (gimp_layer_is_floating_sel (layer))
+    floating_sel_remove (layer);
   else
-    gimp_image_remove_layer (gimage, active_layer);
+    gimp_image_remove_layer (gimage, layer);
 
   gimp_image_flush (gimage);
 }
@@ -300,11 +299,11 @@ layers_text_discard_cmd_callback (GtkAction *action,
                                   gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  if (GIMP_IS_TEXT_LAYER (active_layer))
-    gimp_text_layer_discard (GIMP_TEXT_LAYER (active_layer));
+  if (GIMP_IS_TEXT_LAYER (layer))
+    gimp_text_layer_discard (GIMP_TEXT_LAYER (layer));
 }
 
 void
@@ -312,12 +311,12 @@ layers_resize_cmd_callback (GtkAction *action,
 			    gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   GtkWidget *widget;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
   return_if_no_widget (widget, data);
 
-  layers_resize_layer_query (gimage, active_layer, widget);
+  layers_resize_layer_query (gimage, layer, widget);
 }
 
 void
@@ -325,11 +324,10 @@ layers_resize_to_image_cmd_callback (GtkAction *action,
 				     gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  gimp_layer_resize_to_image (active_layer,
-                              gimp_get_user_context (gimage->gimp));
+  gimp_layer_resize_to_image (layer, action_data_get_context (data));
   gimp_image_flush (gimage);
 }
 
@@ -338,13 +336,13 @@ layers_scale_cmd_callback (GtkAction *action,
 			   gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   GtkWidget *widget;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
   return_if_no_widget (widget, data);
 
   layers_scale_layer_query (GIMP_IS_DISPLAY (data) ? data : NULL,
-                            gimage, active_layer, widget);
+                            gimage, layer, widget);
 }
 
 void
@@ -352,10 +350,10 @@ layers_crop_cmd_callback (GtkAction *action,
                           gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   gint       x1, y1, x2, y2;
   gint       off_x, off_y;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
 
   if (! gimp_channel_bounds (gimp_image_get_mask (gimage),
                              &x1, &y1, &x2, &y2))
@@ -364,7 +362,7 @@ layers_crop_cmd_callback (GtkAction *action,
       return;
     }
 
-  gimp_item_offsets (GIMP_ITEM (active_layer), &off_x, &off_y);
+  gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
 
   off_x -= x1;
   off_y -= y1;
@@ -372,8 +370,7 @@ layers_crop_cmd_callback (GtkAction *action,
   gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_ITEM_RESIZE,
                                _("Crop Layer"));
 
-  gimp_item_resize (GIMP_ITEM (active_layer),
-                    gimp_get_user_context (gimage->gimp),
+  gimp_item_resize (GIMP_ITEM (layer), action_data_get_context (data),
                     x2 - x1, y2 - y1, off_x, off_y);
 
   gimp_image_undo_group_end (gimage);
@@ -386,12 +383,12 @@ layers_mask_add_cmd_callback (GtkAction *action,
                               gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   GtkWidget *widget;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
   return_if_no_widget (widget, data);
 
-  layers_add_mask_query (active_layer, widget);
+  layers_add_mask_query (layer, widget);
 }
 
 void
@@ -399,12 +396,12 @@ layers_mask_apply_cmd_callback (GtkAction *action,
                                 gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  if (gimp_layer_get_mask (active_layer))
+  if (gimp_layer_get_mask (layer))
     {
-      gimp_layer_apply_mask (active_layer, GIMP_MASK_APPLY, TRUE);
+      gimp_layer_apply_mask (layer, GIMP_MASK_APPLY, TRUE);
       gimp_image_flush (gimage);
     }
 }
@@ -414,12 +411,12 @@ layers_mask_delete_cmd_callback (GtkAction *action,
                                  gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  if (gimp_layer_get_mask (active_layer))
+  if (gimp_layer_get_mask (layer))
     {
-      gimp_layer_apply_mask (active_layer, GIMP_MASK_DISCARD, TRUE);
+      gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, TRUE);
       gimp_image_flush (gimage);
     }
 }
@@ -431,13 +428,13 @@ layers_mask_to_selection_cmd_callback (GtkAction *action,
 {
   GimpChannelOps  op;
   GimpImage      *gimage;
-  GimpLayer      *active_layer;
+  GimpLayer      *layer;
   GimpLayerMask  *mask;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
 
   op = (GimpChannelOps) value;
 
-  mask = gimp_layer_get_mask (active_layer);
+  mask = gimp_layer_get_mask (layer);
 
   if (mask)
     {
@@ -459,12 +456,12 @@ layers_alpha_add_cmd_callback (GtkAction *action,
                                gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer *layer;
+  return_if_no_layer (gimage, layer, data);
 
-  if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (active_layer)))
+  if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
     {
-      gimp_layer_add_alpha (active_layer);
+      gimp_layer_add_alpha (layer);
       gimp_image_flush (gimage);
     }
 }
@@ -476,13 +473,13 @@ layers_alpha_to_selection_cmd_callback (GtkAction *action,
 {
   GimpChannelOps  op;
   GimpImage      *gimage;
-  GimpLayer      *active_layer;
-  return_if_no_layer (gimage, active_layer, data);
+  GimpLayer      *layer;
+  return_if_no_layer (gimage, layer, data);
 
   op = (GimpChannelOps) value;
 
   gimp_channel_select_alpha (gimp_image_get_mask (gimage),
-                             GIMP_DRAWABLE (active_layer),
+                             GIMP_DRAWABLE (layer),
                              op, FALSE, 0.0, 0.0);
   gimp_image_flush (gimage);
 }
@@ -506,7 +503,7 @@ layers_flatten_image_cmd_callback (GtkAction *action,
   GimpImage *gimage;
   return_if_no_image (gimage, data);
 
-  gimp_image_flatten (gimage, gimp_get_user_context (gimage->gimp));
+  gimp_image_flatten (gimage, action_data_get_context (data));
   gimp_image_flush (gimage);
 }
 
@@ -515,12 +512,12 @@ layers_text_tool_cmd_callback (GtkAction *action,
                                gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   GtkWidget *widget;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
   return_if_no_widget (widget, data);
 
-  layers_text_tool (active_layer, widget);
+  layers_text_tool (layer, widget);
 }
 
 void
@@ -528,12 +525,12 @@ layers_edit_attributes_cmd_callback (GtkAction *action,
 				     gpointer   data)
 {
   GimpImage *gimage;
-  GimpLayer *active_layer;
+  GimpLayer *layer;
   GtkWidget *widget;
-  return_if_no_layer (gimage, active_layer, data);
+  return_if_no_layer (gimage, layer, data);
   return_if_no_widget (widget, data);
 
-  layers_edit_layer_query (active_layer, widget);
+  layers_edit_layer_query (layer, widget);
 }
 
 void
diff --git a/app/actions/select-actions.c b/app/actions/select-actions.c
index dee854501f..7ebe7e838d 100644
--- a/app/actions/select-actions.c
+++ b/app/actions/select-actions.c
@@ -41,21 +41,27 @@
 
 static GimpActionEntry select_actions[] =
 {
-  { "select-menu", NULL,
-    N_("_Select") },
+  { "selection-editor-popup", GIMP_STOCK_TOOL_RECT_SELECT,
+    N_("Selection Editor Menu"), NULL, NULL, NULL,
+    GIMP_HELP_SELECTION_DIALOG },
+
+  { "select-menu", NULL, N_("_Select") },
 
   { "select-all", GIMP_STOCK_SELECTION_ALL,
-    N_("_All"), "<control>A", NULL,
+    N_("_All"), "<control>A",
+    N_("Select all"),
     G_CALLBACK (select_all_cmd_callback),
     GIMP_HELP_SELECTION_ALL },
 
   { "select-none", GIMP_STOCK_SELECTION_NONE,
-    N_("_None"), "<control><shift>A", NULL,
+    N_("_None"), "<control><shift>A",
+    N_("Select none"),
     G_CALLBACK (select_none_cmd_callback),
     GIMP_HELP_SELECTION_NONE },
 
   { "select-invert", GIMP_STOCK_INVERT,
-    N_("_Invert"), "<control>I", NULL,
+    N_("_Invert"), "<control>I",
+    N_("Invert selection"),
     G_CALLBACK (select_invert_cmd_callback),
     GIMP_HELP_SELECTION_INVERT },
 
@@ -95,12 +101,20 @@ static GimpActionEntry select_actions[] =
     GIMP_HELP_SELECTION_BORDER },
 
   { "select-save", GIMP_STOCK_SELECTION_TO_CHANNEL,
-    N_("Save to _Channel"), NULL, NULL,
+    N_("Save to _Channel"), NULL,
+    N_("Save selection to channel"),
     G_CALLBACK (select_save_cmd_callback),
     GIMP_HELP_SELECTION_TO_CHANNEL },
 
+  { "select-stroke", GIMP_STOCK_SELECTION_STROKE,
+    N_("_Stroke Selection..."), NULL,
+    N_("Stroke selection"),
+    G_CALLBACK (select_stroke_cmd_callback),
+    GIMP_HELP_SELECTION_STROKE },
+
   { "select-to-vectors", GIMP_STOCK_SELECTION_TO_PATH,
-    N_("To _Path"), NULL, NULL,
+    N_("To _Path"), NULL,
+    N_("Selection to path"),
     G_CALLBACK (vectors_selection_to_vectors_cmd_callback),
     GIMP_HELP_SELECTION_TO_PATH }
 };
@@ -118,40 +132,41 @@ void
 select_actions_update (GimpActionGroup *group,
                        gpointer         data)
 {
-  GimpImage   *gimage;
-  GimpVectors *vectors = NULL;
-  gboolean     fs      = FALSE;
-  gboolean     lp      = FALSE;
-  gboolean     sel     = FALSE;
+  GimpImage    *gimage;
+  GimpDrawable *drawable = NULL;
+  GimpVectors  *vectors  = NULL;
+  gboolean      fs       = FALSE;
+  gboolean      sel      = FALSE;
 
   gimage = action_data_get_image (data);
 
   if (gimage)
     {
-      fs  = (gimp_image_floating_sel (gimage) != NULL);
-      lp  = ! gimp_image_is_empty (gimage);
-      sel = ! gimp_channel_is_empty (gimp_image_get_mask (gimage));
+      drawable = gimp_image_active_drawable (gimage);
+      vectors  = gimp_image_get_active_vectors (gimage);
 
-      vectors = gimp_image_get_active_vectors (gimage);
+      fs  = (gimp_image_floating_sel (gimage) != NULL);
+      sel = ! gimp_channel_is_empty (gimp_image_get_mask (gimage));
     }
 
 #define SET_SENSITIVE(action,condition) \
         gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
 
-  SET_SENSITIVE ("select-all",          lp);
-  SET_SENSITIVE ("select-none",         lp && sel);
-  SET_SENSITIVE ("select-invert",       lp && sel);
-  SET_SENSITIVE ("select-from-vectors", lp && vectors);
-  SET_SENSITIVE ("select-float",        lp && sel);
+  SET_SENSITIVE ("select-all",          drawable);
+  SET_SENSITIVE ("select-none",         drawable && sel);
+  SET_SENSITIVE ("select-invert",       drawable && sel);
+  SET_SENSITIVE ("select-from-vectors", vectors);
+  SET_SENSITIVE ("select-float",        drawable && sel);
 
-  SET_SENSITIVE ("select-feather",      lp && sel);
-  SET_SENSITIVE ("select-sharpen",      lp && sel);
-  SET_SENSITIVE ("select-shrink",       lp && sel);
-  SET_SENSITIVE ("select-grow",         lp && sel);
-  SET_SENSITIVE ("select-border",       lp && sel);
+  SET_SENSITIVE ("select-feather",      drawable && sel);
+  SET_SENSITIVE ("select-sharpen",      drawable && sel);
+  SET_SENSITIVE ("select-shrink",       drawable && sel);
+  SET_SENSITIVE ("select-grow",         drawable && sel);
+  SET_SENSITIVE ("select-border",       drawable && sel);
 
-  SET_SENSITIVE ("select-save",         sel && !fs);
-  SET_SENSITIVE ("select-to-vectors",   sel && !fs);
+  SET_SENSITIVE ("select-save",         drawable && sel && !fs);
+  SET_SENSITIVE ("select-stroke",       drawable && sel);
+  SET_SENSITIVE ("select-to-vectors",   drawable && sel && !fs);
 
 #undef SET_SENSITIVE
 }
diff --git a/app/actions/select-commands.c b/app/actions/select-commands.c
index 43efc9a97a..fb3385958c 100644
--- a/app/actions/select-commands.c
+++ b/app/actions/select-commands.c
@@ -38,6 +38,7 @@
 #include "display/gimpdisplayshell.h"
 
 #include "gui/dialogs.h"
+#include "gui/stroke-dialog.h"
 
 #include "actions.h"
 #include "select-commands.h"
@@ -274,6 +275,46 @@ select_save_cmd_callback (GtkAction *action,
                                     "gimp-channel-list", -1);
 }
 
+void
+select_stroke_cmd_callback (GtkAction *action,
+                            gpointer   data)
+{
+  GimpImage    *gimage;
+  GimpDrawable *drawable;
+  GtkWidget    *widget;
+  return_if_no_drawable (gimage, drawable, data);
+  return_if_no_widget (widget, data);
+
+  select_stroke (GIMP_ITEM (gimp_image_get_mask (gimage)), widget);
+}
+
+void
+select_stroke (GimpItem  *item,
+               GtkWidget *parent)
+{
+  GimpImage    *gimage;
+  GimpDrawable *active_drawable;
+  GtkWidget    *dialog;
+
+  g_return_if_fail (GIMP_IS_ITEM (item));
+  g_return_if_fail (GTK_IS_WIDGET (parent));
+
+  gimage = gimp_item_get_image (item);
+
+  active_drawable = gimp_image_active_drawable (gimage);
+
+  if (! active_drawable)
+    {
+      g_message (_("There is no active layer or channel to stroke to."));
+      return;
+    }
+
+  dialog = stroke_dialog_new (item, GIMP_STOCK_SELECTION_STROKE,
+                              GIMP_HELP_SELECTION_STROKE,
+                              parent);
+  gtk_widget_show (dialog);
+}
+
 
 /*  private functions  */
 
diff --git a/app/actions/select-commands.h b/app/actions/select-commands.h
index 37cb5e0077..f8f457dc31 100644
--- a/app/actions/select-commands.h
+++ b/app/actions/select-commands.h
@@ -42,6 +42,11 @@ void   select_grow_cmd_callback         (GtkAction *action,
                                          gpointer   data);
 void   select_save_cmd_callback         (GtkAction *action,
                                          gpointer   data);
+void   select_stroke_cmd_callback       (GtkAction *action,
+                                         gpointer   data);
+
+void   select_stroke                    (GimpItem  *item,
+                                         GtkWidget *parent);
 
 
 #endif /* __SELECT_COMMANDS_H__ */
diff --git a/app/actions/vectors-actions.c b/app/actions/vectors-actions.c
index 4c31d32e1b..7db84fb6aa 100644
--- a/app/actions/vectors-actions.c
+++ b/app/actions/vectors-actions.c
@@ -93,13 +93,9 @@ static GimpActionEntry vectors_actions[] =
     G_CALLBACK (vectors_lower_to_bottom_cmd_callback),
     GIMP_HELP_PATH_LOWER_TO_BOTTOM },
 
-  { "vectors-selection-to-vectors", GIMP_STOCK_SELECTION_TO_PATH,
-    N_("Selecti_on to Path"), NULL, NULL,
-    G_CALLBACK (vectors_selection_to_vectors_cmd_callback),
-    GIMP_HELP_SELECTION_TO_PATH },
-
   { "vectors-stroke", GIMP_STOCK_PATH_STROKE,
-    N_("Stro_ke Path..."), NULL, NULL,
+    N_("Stro_ke Path..."), NULL,
+    N_("Stroke path"),
     G_CALLBACK (vectors_stroke_cmd_callback),
     GIMP_HELP_PATH_STROKE },
 
@@ -147,6 +143,19 @@ static GimpEnumActionEntry vectors_to_selection_actions[] =
     GIMP_HELP_PATH_SELECTION_INTERSECT }
 };
 
+static GimpEnumActionEntry vectors_selection_to_vectors_actions[] =
+{
+  { "vectors-selection-to-vectors", GIMP_STOCK_SELECTION_TO_PATH,
+    N_("Selecti_on to Path"), NULL, NULL,
+    FALSE,
+    GIMP_HELP_SELECTION_TO_PATH },
+
+  { "vectors-selection-to-vectors-advanced", GIMP_STOCK_SELECTION_TO_PATH,
+    N_("Selection to Path (_Advanced)"), NULL, NULL,
+    TRUE,
+    GIMP_HELP_SELECTION_TO_PATH }
+};
+
 
 void
 vectors_actions_setup (GimpActionGroup *group)
@@ -159,6 +168,11 @@ vectors_actions_setup (GimpActionGroup *group)
                                       vectors_to_selection_actions,
                                       G_N_ELEMENTS (vectors_to_selection_actions),
                                       G_CALLBACK (vectors_to_selection_cmd_callback));
+
+  gimp_action_group_add_enum_actions (group,
+                                      vectors_selection_to_vectors_actions,
+                                      G_N_ELEMENTS (vectors_selection_to_vectors_actions),
+                                      G_CALLBACK (vectors_selection_to_vectors_cmd_callback));
 }
 
 void
diff --git a/app/actions/vectors-commands.c b/app/actions/vectors-commands.c
index e375e0e89b..b751123f52 100644
--- a/app/actions/vectors-commands.c
+++ b/app/actions/vectors-commands.c
@@ -194,12 +194,13 @@ vectors_to_selection_cmd_callback (GtkAction *action,
 
 void
 vectors_selection_to_vectors_cmd_callback (GtkAction *action,
+                                           gint       value,
                                            gpointer   data)
 {
   GimpImage *gimage;
   return_if_no_image (gimage, data);
 
-  vectors_selection_to_vectors (gimage, FALSE);
+  vectors_selection_to_vectors (gimage, value);
 }
 
 void
diff --git a/app/actions/vectors-commands.h b/app/actions/vectors-commands.h
index c461e3a383..666a47ef3a 100644
--- a/app/actions/vectors-commands.h
+++ b/app/actions/vectors-commands.h
@@ -40,6 +40,7 @@ void   vectors_to_selection_cmd_callback         (GtkAction   *action,
                                                   gint         value,
                                                   gpointer     data);
 void   vectors_selection_to_vectors_cmd_callback (GtkAction   *action,
+                                                  gint         value,
                                                   gpointer     data);
 void   vectors_stroke_cmd_callback               (GtkAction   *action,
                                                   gpointer     data);
diff --git a/app/dialogs/dialogs-constructors.c b/app/dialogs/dialogs-constructors.c
index 4a3a0324e0..00c0801154 100644
--- a/app/dialogs/dialogs-constructors.c
+++ b/app/dialogs/dialogs-constructors.c
@@ -411,7 +411,6 @@ dialogs_document_list_new (GimpDialogFactory *factory,
                                  context->gimp->documents,
                                  context,
                                  preview_size, 1,
-                                 file_file_open_dialog,
                                  factory->menu_factory);
 
   return dialogs_dockable_new (view,
@@ -614,7 +613,6 @@ dialogs_document_grid_new (GimpDialogFactory *factory,
                                  context->gimp->documents,
                                  context,
                                  preview_size, 1,
-                                 file_file_open_dialog,
                                  factory->menu_factory);
 
   return dialogs_dockable_new (view,
@@ -695,9 +693,8 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
 			       GimpContext       *context,
                                gint               preview_size)
 {
-  GimpVectorsTreeView *vectors_view;
-  GtkWidget           *view;
-  GtkWidget           *dockable;
+  GtkWidget *view;
+  GtkWidget *dockable;
 
   if (preview_size < 1)
     preview_size = context->gimp->config->layer_preview_size;
@@ -713,11 +710,6 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
                              factory->menu_factory, "<Vectors>",
                              "/vectors-popup");
 
-  vectors_view = GIMP_VECTORS_TREE_VIEW (view);
-
-  vectors_view->stroke_item_func          = vectors_stroke_vectors;
-  vectors_view->selection_to_vectors_func = vectors_selection_to_vectors;
-
   dockable = dialogs_dockable_new (view,
 				   _("Paths"), NULL,
                                    GIMP_STOCK_PATHS,
@@ -758,14 +750,11 @@ dialogs_histogram_editor_new (GimpDialogFactory *factory,
                               GimpContext       *context,
                               gint               preview_size)
 {
-  GimpHistogramEditor *histogram_editor;
-  GtkWidget           *view;
-  GtkWidget           *dockable;
+  GtkWidget *view;
+  GtkWidget *dockable;
 
   view = gimp_histogram_editor_new (gimp_context_get_image (context));
 
-  histogram_editor = GIMP_HISTOGRAM_EDITOR (view);
-
   dockable = dialogs_dockable_new (view,
 				   _("Histogram"), NULL,
                                    GIMP_STOCK_HISTOGRAM,
@@ -781,16 +770,11 @@ dialogs_selection_editor_new (GimpDialogFactory *factory,
                               GimpContext       *context,
                               gint               preview_size)
 {
-  GimpSelectionEditor *selection_editor;
-  GtkWidget           *view;
-  GtkWidget           *dockable;
+  GtkWidget *view;
+  GtkWidget *dockable;
 
-  view = gimp_selection_editor_new (gimp_context_get_image (context));
-
-  selection_editor = GIMP_SELECTION_EDITOR (view);
-
-  selection_editor->stroke_item_func          = edit_stroke_selection;
-  selection_editor->selection_to_vectors_func = vectors_selection_to_vectors;
+  view = gimp_selection_editor_new (gimp_context_get_image (context),
+                                    factory->menu_factory);
 
   dockable = dialogs_dockable_new (view,
 				   _("Selection"), _("Selection Editor"),
@@ -811,7 +795,8 @@ dialogs_undo_history_new (GimpDialogFactory *factory,
   GtkWidget *dockable;
   GimpImage *gimage;
 
-  editor = gimp_undo_editor_new (context->gimp->config);
+  editor = gimp_undo_editor_new (context->gimp->config,
+                                 factory->menu_factory);
 
   gimage = gimp_context_get_image (context);
   if (gimage)
diff --git a/app/gui/dialogs-constructors.c b/app/gui/dialogs-constructors.c
index 4a3a0324e0..00c0801154 100644
--- a/app/gui/dialogs-constructors.c
+++ b/app/gui/dialogs-constructors.c
@@ -411,7 +411,6 @@ dialogs_document_list_new (GimpDialogFactory *factory,
                                  context->gimp->documents,
                                  context,
                                  preview_size, 1,
-                                 file_file_open_dialog,
                                  factory->menu_factory);
 
   return dialogs_dockable_new (view,
@@ -614,7 +613,6 @@ dialogs_document_grid_new (GimpDialogFactory *factory,
                                  context->gimp->documents,
                                  context,
                                  preview_size, 1,
-                                 file_file_open_dialog,
                                  factory->menu_factory);
 
   return dialogs_dockable_new (view,
@@ -695,9 +693,8 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
 			       GimpContext       *context,
                                gint               preview_size)
 {
-  GimpVectorsTreeView *vectors_view;
-  GtkWidget           *view;
-  GtkWidget           *dockable;
+  GtkWidget *view;
+  GtkWidget *dockable;
 
   if (preview_size < 1)
     preview_size = context->gimp->config->layer_preview_size;
@@ -713,11 +710,6 @@ dialogs_vectors_list_view_new (GimpDialogFactory *factory,
                              factory->menu_factory, "<Vectors>",
                              "/vectors-popup");
 
-  vectors_view = GIMP_VECTORS_TREE_VIEW (view);
-
-  vectors_view->stroke_item_func          = vectors_stroke_vectors;
-  vectors_view->selection_to_vectors_func = vectors_selection_to_vectors;
-
   dockable = dialogs_dockable_new (view,
 				   _("Paths"), NULL,
                                    GIMP_STOCK_PATHS,
@@ -758,14 +750,11 @@ dialogs_histogram_editor_new (GimpDialogFactory *factory,
                               GimpContext       *context,
                               gint               preview_size)
 {
-  GimpHistogramEditor *histogram_editor;
-  GtkWidget           *view;
-  GtkWidget           *dockable;
+  GtkWidget *view;
+  GtkWidget *dockable;
 
   view = gimp_histogram_editor_new (gimp_context_get_image (context));
 
-  histogram_editor = GIMP_HISTOGRAM_EDITOR (view);
-
   dockable = dialogs_dockable_new (view,
 				   _("Histogram"), NULL,
                                    GIMP_STOCK_HISTOGRAM,
@@ -781,16 +770,11 @@ dialogs_selection_editor_new (GimpDialogFactory *factory,
                               GimpContext       *context,
                               gint               preview_size)
 {
-  GimpSelectionEditor *selection_editor;
-  GtkWidget           *view;
-  GtkWidget           *dockable;
+  GtkWidget *view;
+  GtkWidget *dockable;
 
-  view = gimp_selection_editor_new (gimp_context_get_image (context));
-
-  selection_editor = GIMP_SELECTION_EDITOR (view);
-
-  selection_editor->stroke_item_func          = edit_stroke_selection;
-  selection_editor->selection_to_vectors_func = vectors_selection_to_vectors;
+  view = gimp_selection_editor_new (gimp_context_get_image (context),
+                                    factory->menu_factory);
 
   dockable = dialogs_dockable_new (view,
 				   _("Selection"), _("Selection Editor"),
@@ -811,7 +795,8 @@ dialogs_undo_history_new (GimpDialogFactory *factory,
   GtkWidget *dockable;
   GimpImage *gimage;
 
-  editor = gimp_undo_editor_new (context->gimp->config);
+  editor = gimp_undo_editor_new (context->gimp->config,
+                                 factory->menu_factory);
 
   gimage = gimp_context_get_image (context);
   if (gimage)
diff --git a/app/menus/menus.c b/app/menus/menus.c
index 487d29b5f3..3cccfd96af 100644
--- a/app/menus/menus.c
+++ b/app/menus/menus.c
@@ -260,6 +260,19 @@ menus_init (Gimp *gimp)
                                       "colormap-editor-menu.xml", NULL,
                                       NULL);
 
+  gimp_menu_factory_manager_register (global_menu_factory, "<SelectionEditor>",
+                                      "select",
+                                      "vectors",
+                                      NULL,
+                                      "/selection-editor-popup",
+                                      "selection-editor-menu.xml", NULL,
+                                      NULL);
+
+  gimp_menu_factory_manager_register (global_menu_factory, "<UndoEditor>",
+                                      "edit",
+                                      NULL,
+                                      NULL);
+
   gimp_menu_factory_manager_register (global_menu_factory, "<ErrorConsole>",
                                       "error-console",
                                       NULL,
diff --git a/app/widgets/gimpbufferview.c b/app/widgets/gimpbufferview.c
index 6af7f3ee56..3d3ecc62f9 100644
--- a/app/widgets/gimpbufferview.c
+++ b/app/widgets/gimpbufferview.c
@@ -45,8 +45,6 @@
 static void   gimp_buffer_view_class_init    (GimpBufferViewClass *klass);
 static void   gimp_buffer_view_init          (GimpBufferView      *view);
 
-static void   gimp_buffer_view_select_item   (GimpContainerEditor *editor,
-                                              GimpViewable        *viewable);
 static void   gimp_buffer_view_activate_item (GimpContainerEditor *editor,
                                               GimpViewable        *viewable);
 
@@ -89,7 +87,6 @@ gimp_buffer_view_class_init (GimpBufferViewClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
-  editor_class->select_item   = gimp_buffer_view_select_item;
   editor_class->activate_item = gimp_buffer_view_activate_item;
 }
 
@@ -131,19 +128,19 @@ gimp_buffer_view_new (GimpViewType     view_type,
 
   buffer_view->paste_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
-                                   "buffers-paste");
+                                   "buffers-paste", NULL);
 
   buffer_view->paste_into_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
-                                   "buffers-paste-into");
+                                   "buffers-paste-into", NULL);
 
   buffer_view->paste_as_new_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
-                                   "buffers-paste-as-new");
+                                   "buffers-paste-as-new", NULL);
 
   buffer_view->delete_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "buffers",
-                                   "buffers-delete");
+                                   "buffers-delete", NULL);
 
   gimp_container_view_enable_dnd (editor->view,
 				  GTK_BUTTON (buffer_view->paste_button),
@@ -163,16 +160,6 @@ gimp_buffer_view_new (GimpViewType     view_type,
   return GTK_WIDGET (buffer_view);
 }
 
-static void
-gimp_buffer_view_select_item (GimpContainerEditor *editor,
-			      GimpViewable        *viewable)
-{
-  if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
-    GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
-
-  gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
-}
-
 static void
 gimp_buffer_view_activate_item (GimpContainerEditor *editor,
 				GimpViewable        *viewable)
diff --git a/app/widgets/gimpchanneltreeview.c b/app/widgets/gimpchanneltreeview.c
index 2f177b4d9d..2873432abe 100644
--- a/app/widgets/gimpchanneltreeview.c
+++ b/app/widgets/gimpchanneltreeview.c
@@ -2,7 +2,7 @@
  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  *
  * gimpchanneltreeview.c
- * Copyright (C) 2001-2003 Michael Natterer <mitch@gimp.org>
+ * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,13 +23,11 @@
 
 #include <gtk/gtk.h>
 
-#include "libgimpmath/gimpmath.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "widgets-types.h"
 
 #include "core/gimpchannel.h"
-#include "core/gimpchannel-select.h"
 #include "core/gimpcontainer.h"
 #include "core/gimpimage.h"
 
@@ -48,22 +46,14 @@ static void   gimp_channel_tree_view_init       (GimpChannelTreeView      *view)
 
 static void   gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface);
 
-static void   gimp_channel_tree_view_set_image      (GimpItemTreeView     *item_view,
-						     GimpImage            *gimage);
+static GObject * gimp_channel_tree_view_constructor   (GType              type,
+                                                       guint              n_params,
+                                                       GObjectConstructParam *params);
+static void   gimp_channel_tree_view_set_image        (GimpItemTreeView  *item_view,
+                                                       GimpImage         *gimage);
 
-static gboolean  gimp_channel_tree_view_select_item (GimpContainerView   *view,
-						     GimpViewable        *item,
-						     gpointer             insert_data);
 static void   gimp_channel_tree_view_set_preview_size (GimpContainerView *view);
 
-static void   gimp_channel_tree_view_toselection_clicked
-                                                    (GtkWidget           *widget,
-						     GimpChannelTreeView *view);
-static void   gimp_channel_tree_view_toselection_extended_clicked
-                                                    (GtkWidget           *widget,
-						     guint                state,
-						     GimpChannelTreeView *view);
-
 
 static GimpDrawableTreeViewClass  *parent_class      = NULL;
 static GimpContainerViewInterface *parent_view_iface = NULL;
@@ -110,10 +100,13 @@ gimp_channel_tree_view_get_type (void)
 static void
 gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass)
 {
+  GObjectClass          *object_class    = G_OBJECT_CLASS (klass);
   GimpItemTreeViewClass *item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->constructor        = gimp_channel_tree_view_constructor;
+
   item_view_class->set_image       = gimp_channel_tree_view_set_image;
 
   item_view_class->get_container   = gimp_image_get_channels;
@@ -145,7 +138,30 @@ gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass)
 static void
 gimp_channel_tree_view_init (GimpChannelTreeView *view)
 {
-  gchar *str;
+}
+
+static void
+gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
+{
+  parent_view_iface = g_type_interface_peek_parent (view_iface);
+
+  view_iface->set_preview_size = gimp_channel_tree_view_set_preview_size;
+}
+
+static GObject *
+gimp_channel_tree_view_constructor (GType                  type,
+                                    guint                  n_params,
+                                    GObjectConstructParam *params)
+{
+  GObject             *object;
+  GimpEditor          *editor;
+  GimpChannelTreeView *view;
+  gchar               *str;
+
+  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
+
+  editor = GIMP_EDITOR (object);
+  view   = GIMP_CHANNEL_TREE_VIEW (object);
 
   str = g_strdup_printf (_("Channel to Selection\n"
                            "%s  Add\n"
@@ -158,12 +174,18 @@ gimp_channel_tree_view_init (GimpChannelTreeView *view)
                          gimp_get_mod_name_control ());
 
   view->toselection_button =
-    gimp_editor_add_button (GIMP_EDITOR (view),
-                            GIMP_STOCK_SELECTION_REPLACE, str,
-                            GIMP_HELP_CHANNEL_SELECTION_REPLACE,
-                            G_CALLBACK (gimp_channel_tree_view_toselection_clicked),
-                            G_CALLBACK (gimp_channel_tree_view_toselection_extended_clicked),
-                            view);
+    gimp_editor_add_action_button (GIMP_EDITOR (view), "channels",
+                                   "channels-selection-replace",
+                                   "channels-selection-intersect",
+                                   GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+                                   "channels-selection-subtract",
+                                   GDK_CONTROL_MASK,
+                                   "channels-selection-add",
+                                   GDK_SHIFT_MASK,
+                                   NULL);
+
+  gimp_help_set_help_data (view->toselection_button, str,
+                           GIMP_HELP_CHANNEL_SELECTION_REPLACE);
 
   g_free (str);
 
@@ -174,16 +196,7 @@ gimp_channel_tree_view_init (GimpChannelTreeView *view)
 				  GTK_BUTTON (view->toselection_button),
 				  GIMP_TYPE_CHANNEL);
 
-  gtk_widget_set_sensitive (view->toselection_button, FALSE);
-}
-
-static void
-gimp_channel_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
-{
-  parent_view_iface = g_type_interface_peek_parent (view_iface);
-
-  view_iface->select_item      = gimp_channel_tree_view_select_item;
-  view_iface->set_preview_size = gimp_channel_tree_view_set_preview_size;
+  return object;
 }
 
 
@@ -226,32 +239,6 @@ gimp_channel_tree_view_set_image (GimpItemTreeView *item_view,
 
 /*  GimpContainerView methods  */
 
-static gboolean
-gimp_channel_tree_view_select_item (GimpContainerView *view,
-				    GimpViewable      *item,
-				    gpointer           insert_data)
-{
-  GimpItemTreeView    *item_view = GIMP_ITEM_TREE_VIEW (view);
-  GimpChannelTreeView *tree_view = GIMP_CHANNEL_TREE_VIEW (view);
-  gboolean             success;
-
-  success = parent_view_iface->select_item (view, item, insert_data);
-
-  if (item_view->gimage)
-    {
-      gboolean floating_sel;
-
-      floating_sel = (gimp_image_floating_sel (item_view->gimage) != NULL);
-
-      gtk_widget_set_sensitive (GIMP_EDITOR (view)->button_box, ! floating_sel);
-    }
-
-  gtk_widget_set_sensitive (tree_view->toselection_button,
-                            success && item != NULL);
-
-  return success;
-}
-
 static void
 gimp_channel_tree_view_set_preview_size (GimpContainerView *view)
 {
@@ -266,48 +253,3 @@ gimp_channel_tree_view_set_preview_size (GimpContainerView *view)
     gimp_component_editor_set_preview_size (GIMP_COMPONENT_EDITOR (channel_view->component_editor),
                                             preview_size);
 }
-
-static void
-gimp_channel_tree_view_toselection_clicked (GtkWidget           *widget,
-					    GimpChannelTreeView *view)
-{
-  gimp_channel_tree_view_toselection_extended_clicked (widget, 0, view);
-}
-
-static void
-gimp_channel_tree_view_toselection_extended_clicked (GtkWidget           *widget,
-						     guint                state,
-						     GimpChannelTreeView *view)
-{
-  GimpImage *gimage;
-  GimpItem  *item;
-
-  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
-
-  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
-
-  if (item)
-    {
-      GimpChannelOps operation = GIMP_CHANNEL_OP_REPLACE;
-
-      if (state & GDK_SHIFT_MASK)
-	{
-	  if (state & GDK_CONTROL_MASK)
-	    operation = GIMP_CHANNEL_OP_INTERSECT;
-	  else
-	    operation = GIMP_CHANNEL_OP_ADD;
-	}
-      else if (state & GDK_CONTROL_MASK)
-	{
-	  operation = GIMP_CHANNEL_OP_SUBTRACT;
-	}
-
-      gimp_channel_select_channel (gimp_image_get_mask (gimage),
-                                   _("Channel to Selection"),
-                                   GIMP_CHANNEL (item),
-                                   0, 0,
-                                   operation,
-                                   FALSE, 0.0, 0.0);
-      gimp_image_flush (gimage);
-    }
-}
diff --git a/app/widgets/gimpcolormapeditor.c b/app/widgets/gimpcolormapeditor.c
index 45ab996674..67aa66f3ca 100644
--- a/app/widgets/gimpcolormapeditor.c
+++ b/app/widgets/gimpcolormapeditor.c
@@ -333,14 +333,14 @@ gimp_colormap_editor_new (GimpImage       *gimage,
   GtkWidget          *frame;
   GtkWidget          *table;
 
-  g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL);
+  g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL);
   g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
 
-  editor = g_object_new (GIMP_TYPE_COLORMAP_EDITOR, NULL);
-
-  gimp_editor_create_menu (GIMP_EDITOR (editor),
-                           menu_factory, "<ColormapEditor>",
-                           "/colormap-editor-popup", editor);
+  editor = g_object_new (GIMP_TYPE_COLORMAP_EDITOR,
+                         "menu-factory",    menu_factory,
+                         "menu-identifier", "<ColormapEditor>",
+                         "ui-path",         "/colormap-editor-popup",
+                         NULL);
 
   /*  The palette frame  */
   frame = gtk_frame_new (NULL);
@@ -758,7 +758,7 @@ gimp_colormap_preview_button_press (GtkWidget          *widget,
                               GIMP_EDITOR (editor)->popup_data);
       gimp_ui_manager_ui_popup (GIMP_EDITOR (editor)->ui_manager,
                                 GIMP_EDITOR (editor)->ui_path,
-                                GIMP_EDITOR (editor)->ui_manager,
+                                GIMP_EDITOR (editor)->popup_data,
                                 GTK_WIDGET (editor),
                                 NULL, NULL, NULL);
       return TRUE;
diff --git a/app/widgets/gimpcontainereditor.c b/app/widgets/gimpcontainereditor.c
index 8c1d430a4a..a0d9b0faea 100644
--- a/app/widgets/gimpcontainereditor.c
+++ b/app/widgets/gimpcontainereditor.c
@@ -219,6 +219,9 @@ gimp_container_editor_select_item (GtkWidget           *widget,
   if (klass->select_item)
     klass->select_item (editor, viewable);
 
+  if (GIMP_EDITOR (editor->view)->ui_manager)
+    gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
+
   return TRUE;
 }
 
diff --git a/app/widgets/gimpcontainergridview.c b/app/widgets/gimpcontainergridview.c
index 9cd57fb3bb..45ea6c5ff1 100644
--- a/app/widgets/gimpcontainergridview.c
+++ b/app/widgets/gimpcontainergridview.c
@@ -234,7 +234,6 @@ gimp_container_grid_view_view_iface_init (GimpContainerViewInterface *view_iface
   view_iface->select_item      = gimp_container_grid_view_select_item;
   view_iface->clear_items      = gimp_container_grid_view_clear_items;
   view_iface->set_preview_size = gimp_container_grid_view_set_preview_size;
-
 }
 
 GtkWidget *
diff --git a/app/widgets/gimpcontainerview.c b/app/widgets/gimpcontainerview.c
index 3a5abd7281..b4cb0eabb8 100644
--- a/app/widgets/gimpcontainerview.c
+++ b/app/widgets/gimpcontainerview.c
@@ -714,8 +714,19 @@ gimp_container_view_item_selected (GimpContainerView *view,
 
   private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view);
 
+  /* HACK */
+  if (private->container && private->context)
+    {
+      gimp_context_set_by_type (private->context,
+                                private->container->children_type,
+                                GIMP_OBJECT (viewable));
+
+      return TRUE;
+    }
+
   success = gimp_container_view_select_item (view, viewable);
 
+#if 0
   if (success && private->container && private->context)
     {
       GimpContext *context;
@@ -739,6 +750,7 @@ gimp_container_view_item_selected (GimpContainerView *view,
 
       g_object_unref (context);
     }
+#endif
 
   return success;
 }
@@ -967,18 +979,8 @@ gimp_container_view_context_changed (GimpContext       *context,
 				     GimpViewable      *viewable,
 				     GimpContainerView *view)
 {
-  GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view);
-  gpointer                  insert_data;
-  gboolean                  success = FALSE;
-
-  insert_data = g_hash_table_lookup (private->hash_table, viewable);
-
-  g_signal_emit (view, view_signals[SELECT_ITEM], 0,
-                 viewable, insert_data, &success);
-
-  if (! success)
-    g_warning ("gimp_container_view_context_changed(): select_item() failed "
-               "(should not happen)");
+  if (! gimp_container_view_select_item (view, viewable))
+    g_warning ("%s: select_item() failed (should not happen)", G_STRFUNC);
 }
 
 static void
@@ -989,10 +991,11 @@ gimp_container_view_viewable_dropped (GtkWidget    *widget,
   GimpContainerView        *view    = GIMP_CONTAINER_VIEW (data);
   GimpContainerViewPrivate *private = GIMP_CONTAINER_VIEW_GET_PRIVATE (view);
 
-  if (private->context && private->container)
-    gimp_context_set_by_type (private->context,
-                              private->container->children_type,
-                              GIMP_OBJECT (viewable));
+  if (viewable && private->container &&
+      gimp_container_have (private->container, GIMP_OBJECT (viewable)))
+    {
+      gimp_container_view_item_selected (view, viewable);
+    }
 }
 
 static void
diff --git a/app/widgets/gimpdatafactoryview.c b/app/widgets/gimpdatafactoryview.c
index 93b09ccfb9..2c23d989ff 100644
--- a/app/widgets/gimpdatafactoryview.c
+++ b/app/widgets/gimpdatafactoryview.c
@@ -51,8 +51,6 @@
 static void   gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass);
 static void   gimp_data_factory_view_init       (GimpDataFactoryView      *view);
 
-static void   gimp_data_factory_view_select_item    (GimpContainerEditor *editor,
-                                                     GimpViewable        *viewable);
 static void   gimp_data_factory_view_activate_item  (GimpContainerEditor *editor,
                                                      GimpViewable        *viewable);
 static void gimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell,
@@ -99,7 +97,6 @@ gimp_data_factory_view_class_init (GimpDataFactoryViewClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
-  editor_class->select_item   = gimp_data_factory_view_select_item;
   editor_class->activate_item = gimp_data_factory_view_activate_item;
 }
 
@@ -211,7 +208,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
 
       factory_view->edit_button =
         gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
-                                       str);
+                                       str, NULL);
 
       g_free (str);
     }
@@ -222,7 +219,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
 
       factory_view->new_button =
         gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
-                                       str);
+                                       str, NULL);
 
       g_free (str);
     }
@@ -231,7 +228,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
 
   factory_view->duplicate_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
-                                   str);
+                                   str, NULL);
 
   g_free (str);
 
@@ -239,7 +236,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
 
   factory_view->delete_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
-                                   str);
+                                   str, NULL);
 
   g_free (str);
 
@@ -247,7 +244,7 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
 
   factory_view->refresh_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), action_group,
-                                   str);
+                                   str, NULL);
 
   g_free (str);
 
@@ -268,16 +265,6 @@ gimp_data_factory_view_construct (GimpDataFactoryView *factory_view,
   return TRUE;
 }
 
-static void
-gimp_data_factory_view_select_item (GimpContainerEditor *editor,
-				    GimpViewable        *viewable)
-{
-  if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
-    GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
-
-  gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
-}
-
 static void
 gimp_data_factory_view_activate_item (GimpContainerEditor *editor,
 				      GimpViewable        *viewable)
diff --git a/app/widgets/gimpdockable.c b/app/widgets/gimpdockable.c
index ce7293006f..332c38e84d 100644
--- a/app/widgets/gimpdockable.c
+++ b/app/widgets/gimpdockable.c
@@ -909,7 +909,7 @@ gimp_dockable_menu_end (GimpDockable *dockable)
                                               &dialog_ui_path,
                                               &dialog_popup_data);
 
-  if (dialog_ui_manager)
+  if (dialog_ui_manager && dialog_ui_path)
     {
       GtkWidget *child_menu_widget;
 
@@ -942,7 +942,7 @@ gimp_dockable_show_menu (GimpDockable *dockable)
                                               &dialog_ui_path,
                                               &dialog_popup_data);
 
-  if (dialog_ui_manager)
+  if (dialog_ui_manager && dialog_ui_path)
     {
       GtkWidget   *child_menu_widget;
       GtkAction   *child_menu_action;
diff --git a/app/widgets/gimpdocumentview.c b/app/widgets/gimpdocumentview.c
index 2d9be9e073..6a421e874d 100644
--- a/app/widgets/gimpdocumentview.c
+++ b/app/widgets/gimpdocumentview.c
@@ -21,64 +21,34 @@
 
 #include "config.h"
 
-#include <string.h>
-
 #include <gtk/gtk.h>
 
-#include "libgimpthumb/gimpthumb.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "widgets-types.h"
 
-#ifdef __GNUC__
-#warning FIXME #include "display/display-types.h"
-#endif
-#include "display/display-types.h"
-
 #include "core/gimp.h"
 #include "core/gimpcontainer.h"
 #include "core/gimpcontext.h"
-#include "core/gimpimage.h"
 #include "core/gimpimagefile.h"
 
-#include "file/file-open.h"
-#include "file/file-utils.h"
-
-#include "display/gimpdisplay.h"
-
 #include "gimpcontainerview.h"
 #include "gimpdocumentview.h"
 #include "gimpdnd.h"
 #include "gimphelp-ids.h"
+#include "gimpuimanager.h"
 #include "gimpwidgets-utils.h"
 
 #include "gimp-intl.h"
 
 
-static void   gimp_document_view_class_init (GimpDocumentViewClass *klass);
-static void   gimp_document_view_init       (GimpDocumentView      *view);
+static void    gimp_document_view_class_init    (GimpDocumentViewClass *klass);
+static void    gimp_document_view_init          (GimpDocumentView      *view);
 
-static void   gimp_document_view_open_clicked          (GtkWidget        *widget,
-                                                        GimpDocumentView *view);
-static void   gimp_document_view_open_extended_clicked (GtkWidget        *widget,
-                                                        guint             state,
-                                                        GimpDocumentView *view);
-static void   gimp_document_view_remove_clicked        (GtkWidget        *widget,
-                                                        GimpDocumentView *view);
-static void   gimp_document_view_refresh_clicked       (GtkWidget        *widget,
-                                                        GimpDocumentView *view);
-static void   gimp_document_view_refresh_extended_clicked (GtkWidget     *widget,
-                                                           guint          state,
-                                                        GimpDocumentView *view);
-
-static void   gimp_document_view_select_item     (GimpContainerEditor *editor,
-                                                  GimpViewable        *viewable);
-static void   gimp_document_view_activate_item   (GimpContainerEditor *editor,
-                                                  GimpViewable        *viewable);
-static void   gimp_document_view_open_image      (GimpDocumentView    *view,
-                                                  GimpImagefile       *imagefile);
-static GList * gimp_document_view_drag_file      (GtkWidget           *widget,
-                                                  gpointer             data);
+static void    gimp_document_view_activate_item (GimpContainerEditor *editor,
+                                                 GimpViewable        *viewable);
+static GList * gimp_document_view_drag_file     (GtkWidget           *widget,
+                                                 gpointer             data);
 
 
 static GimpContainerEditorClass *parent_class = NULL;
@@ -119,7 +89,6 @@ gimp_document_view_class_init (GimpDocumentViewClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
-  editor_class->select_item   = gimp_document_view_select_item;
   editor_class->activate_item = gimp_document_view_activate_item;
 }
 
@@ -132,20 +101,17 @@ gimp_document_view_init (GimpDocumentView *view)
 }
 
 GtkWidget *
-gimp_document_view_new (GimpViewType            view_type,
-                        GimpContainer          *container,
-                        GimpContext            *context,
-                        gint                    preview_size,
-                        gint                    preview_border_width,
-                        GimpFileOpenDialogFunc  file_open_dialog_func,
-                        GimpMenuFactory        *menu_factory)
+gimp_document_view_new (GimpViewType     view_type,
+                        GimpContainer   *container,
+                        GimpContext     *context,
+                        gint             preview_size,
+                        gint             preview_border_width,
+                        GimpMenuFactory *menu_factory)
 {
   GimpDocumentView    *document_view;
   GimpContainerEditor *editor;
   gchar               *str;
 
-  g_return_val_if_fail (file_open_dialog_func != NULL, NULL);
-
   document_view = g_object_new (GIMP_TYPE_DOCUMENT_VIEW, NULL);
 
   if (! gimp_container_editor_construct (GIMP_CONTAINER_EDITOR (document_view),
@@ -160,8 +126,6 @@ gimp_document_view_new (GimpViewType            view_type,
       return NULL;
     }
 
-  document_view->file_open_dialog_func = file_open_dialog_func;
-
   editor = GIMP_CONTAINER_EDITOR (document_view);
 
   str = g_strdup_printf (_("Open the selected entry\n"
@@ -171,22 +135,27 @@ gimp_document_view_new (GimpViewType            view_type,
                          gimp_get_mod_name_control ());
 
   document_view->open_button =
-    gimp_editor_add_button (GIMP_EDITOR (editor->view),
-                            GTK_STOCK_OPEN, str,
-                            GIMP_HELP_DOCUMENT_OPEN,
-                            G_CALLBACK (gimp_document_view_open_clicked),
-                            G_CALLBACK (gimp_document_view_open_extended_clicked),
-                            editor);
+    gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
+                                   "documents-open",
+                                   "documents-raise-or-open",
+                                   GDK_SHIFT_MASK,
+                                   "documents-file-open-dialog",
+                                   GDK_CONTROL_MASK,
+                                   NULL);
+  gimp_help_set_help_data (document_view->open_button, str,
+                           GIMP_HELP_DOCUMENT_OPEN);
+  gimp_container_view_enable_dnd (editor->view,
+				  GTK_BUTTON (document_view->open_button),
+				  GIMP_TYPE_IMAGEFILE);
 
   g_free (str);
 
   document_view->remove_button =
-    gimp_editor_add_button (GIMP_EDITOR (editor->view),
-                            GTK_STOCK_REMOVE, _("Remove selected entry"),
-                            GIMP_HELP_DOCUMENT_REMOVE,
-                            G_CALLBACK (gimp_document_view_remove_clicked),
-                            NULL,
-                            editor);
+    gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
+                                   "documents-remove");
+  gimp_container_view_enable_dnd (editor->view,
+				  GTK_BUTTON (document_view->remove_button),
+				  GIMP_TYPE_IMAGEFILE);
 
   str = g_strdup_printf (_("Recreate preview\n"
                            "%s  Reload all previews\n"
@@ -195,27 +164,18 @@ gimp_document_view_new (GimpViewType            view_type,
                          gimp_get_mod_name_control ());
 
   document_view->refresh_button =
-    gimp_editor_add_button (GIMP_EDITOR (editor->view),
-                            GTK_STOCK_REFRESH, str,
-                            GIMP_HELP_DOCUMENT_REFRESH,
-                            G_CALLBACK (gimp_document_view_refresh_clicked),
-                            G_CALLBACK (gimp_document_view_refresh_extended_clicked),
-                            editor);
+    gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "documents",
+                                   "documents-recreate-preview",
+                                   "documents-reload-previews",
+                                   GDK_SHIFT_MASK,
+                                   "documents-remove-dangling",
+                                   GDK_CONTROL_MASK,
+                                   NULL);
+  gimp_help_set_help_data (document_view->refresh_button, str,
+                           GIMP_HELP_DOCUMENT_REFRESH);
 
   g_free (str);
 
-  /*  set button sensitivity  */
-  if (GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item)
-    GIMP_CONTAINER_EDITOR_GET_CLASS (editor)->select_item
-      (editor, (GimpViewable *) gimp_context_get_imagefile (context));
-
-  gimp_container_view_enable_dnd (editor->view,
-				  GTK_BUTTON (document_view->open_button),
-				  GIMP_TYPE_IMAGEFILE);
-  gimp_container_view_enable_dnd (editor->view,
-				  GTK_BUTTON (document_view->remove_button),
-				  GIMP_TYPE_IMAGEFILE);
-
   if (view_type == GIMP_VIEW_TYPE_LIST)
     {
       GtkWidget *dnd_widget;
@@ -227,204 +187,11 @@ gimp_document_view_new (GimpViewType            view_type,
                                 editor);
     }
 
+  gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
+
   return GTK_WIDGET (document_view);
 }
 
-static void
-gimp_document_view_open_clicked (GtkWidget        *widget,
-                                 GimpDocumentView *view)
-{
-  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
-  GimpContext         *context;
-  GimpContainer       *container;
-  GimpImagefile       *imagefile;
-
-  context   = gimp_container_view_get_context (editor->view);
-  container = gimp_container_view_get_container (editor->view);
-
-  imagefile = gimp_context_get_imagefile (context);
-
-  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
-    {
-      gimp_document_view_open_image (view, imagefile);
-    }
-  else
-    {
-      view->file_open_dialog_func (context->gimp, NULL, GTK_WIDGET (view));
-    }
-}
-
-
-typedef struct _RaiseClosure RaiseClosure;
-
-struct _RaiseClosure
-{
-  const gchar *name;
-  gboolean     found;
-};
-
-static void
-gimp_document_view_raise_display (gpointer data,
-                                  gpointer user_data)
-{
-  GimpDisplay  *gdisp   = (GimpDisplay *) data;
-  RaiseClosure *closure = (RaiseClosure *) user_data;
-  const gchar  *uri;
-
-  uri = gimp_object_get_name (GIMP_OBJECT (gdisp->gimage));
-
-  if (uri && ! strcmp (closure->name, uri))
-    {
-      closure->found = TRUE;
-      gtk_window_present (GTK_WINDOW (gdisp->shell));
-    }
-}
-
-static void
-gimp_document_view_open_extended_clicked (GtkWidget        *widget,
-                                          guint             state,
-                                          GimpDocumentView *view)
-{
-  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
-  GimpContext         *context;
-  GimpContainer       *container;
-  GimpImagefile       *imagefile;
-
-  context   = gimp_container_view_get_context (editor->view);
-  container = gimp_container_view_get_container (editor->view);
-
-  imagefile = gimp_context_get_imagefile (context);
-
-  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
-    {
-      if (state & GDK_CONTROL_MASK)
-        {
-          view->file_open_dialog_func (context->gimp,
-                                       gimp_object_get_name (GIMP_OBJECT (imagefile)),
-                                       GTK_WIDGET (view));
-        }
-      else if (state & GDK_SHIFT_MASK)
-        {
-          RaiseClosure closure;
-
-          closure.name  = gimp_object_get_name (GIMP_OBJECT (imagefile));
-          closure.found = FALSE;
-
-          gimp_container_foreach (context->gimp->displays,
-                                  gimp_document_view_raise_display,
-                                  &closure);
-
-          if (! closure.found)
-            gimp_document_view_open_image (view, imagefile);
-        }
-    }
-  else
-    {
-      view->file_open_dialog_func (context->gimp, NULL, GTK_WIDGET (view));
-    }
-}
-
-static void
-gimp_document_view_remove_clicked (GtkWidget        *widget,
-                                   GimpDocumentView *view)
-{
-  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
-  GimpContext         *context;
-  GimpContainer       *container;
-  GimpImagefile       *imagefile;
-
-  context   = gimp_container_view_get_context (editor->view);
-  container = gimp_container_view_get_container (editor->view);
-
-  imagefile = gimp_context_get_imagefile (context);
-
-  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
-    {
-      gimp_container_remove (container, GIMP_OBJECT (imagefile));
-    }
-}
-
-static void
-gimp_document_view_refresh_clicked (GtkWidget        *widget,
-                                    GimpDocumentView *view)
-{
-  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
-  GimpContext         *context;
-  GimpContainer       *container;
-  GimpImagefile       *imagefile;
-
-  context   = gimp_container_view_get_context (editor->view);
-  container = gimp_container_view_get_container (editor->view);
-
-  imagefile = gimp_context_get_imagefile (context);
-
-  if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
-    {
-      gint preview_size;
-
-      preview_size = gimp_container_view_get_preview_size (editor->view, NULL);
-
-      gimp_imagefile_create_thumbnail (imagefile, context, preview_size);
-    }
-}
-
-static void
-gimp_document_view_delete_dangling_foreach (GimpImagefile     *imagefile,
-                                            GimpContainerView *view)
-{
-  if (gimp_thumbnail_peek_image (imagefile->thumbnail) ==
-      GIMP_THUMB_STATE_NOT_FOUND)
-    {
-      gimp_container_remove (gimp_container_view_get_container (view),
-                             GIMP_OBJECT (imagefile));
-    }
-}
-
-static void
-gimp_document_view_refresh_extended_clicked (GtkWidget        *widget,
-                                             guint             state,
-                                             GimpDocumentView *view)
-{
-  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
-  GimpContainer       *container;
-
-  container = gimp_container_view_get_container (editor->view);
-
-  if (state & GDK_CONTROL_MASK)
-    {
-      gimp_container_foreach (container,
-                              (GFunc) gimp_document_view_delete_dangling_foreach,
-                              editor->view);
-    }
-  else if (state & GDK_SHIFT_MASK)
-    {
-      gimp_container_foreach (container,
-                              (GFunc) gimp_imagefile_update,
-                              editor->view);
-    }
-}
-
-static void
-gimp_document_view_select_item (GimpContainerEditor *editor,
-                                GimpViewable        *viewable)
-{
-  GimpDocumentView *view = GIMP_DOCUMENT_VIEW (editor);
-  GimpContainer    *container;
-  gboolean          remove_sensitive = FALSE;
-
-  if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
-    GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
-
-  container = gimp_container_view_get_container (editor->view);
-
-  if (viewable && gimp_container_have (container, GIMP_OBJECT (viewable)))
-    {
-      remove_sensitive = TRUE;
-    }
-
-  gtk_widget_set_sensitive (view->remove_button, remove_sensitive);
-}
-
 static void
 gimp_document_view_activate_item (GimpContainerEditor *editor,
                                   GimpViewable        *viewable)
@@ -439,39 +206,7 @@ gimp_document_view_activate_item (GimpContainerEditor *editor,
 
   if (viewable && gimp_container_have (container, GIMP_OBJECT (viewable)))
     {
-      gimp_document_view_open_clicked (NULL, view);
-    }
-}
-
-static void
-gimp_document_view_open_image (GimpDocumentView *view,
-                               GimpImagefile    *imagefile)
-{
-  GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
-  Gimp                *gimp;
-  const gchar         *uri;
-  GimpImage           *gimage;
-  GimpPDBStatusType    status;
-  GError              *error = NULL;
-
-  gimp = gimp_container_view_get_context (editor->view)->gimp;
-
-  uri = gimp_object_get_name (GIMP_OBJECT (imagefile));
-
-  gimage = file_open_with_display (gimp, gimp_get_user_context (gimp),
-                                   uri, &status, &error);
-
-  if (! gimage && status != GIMP_PDB_CANCEL)
-    {
-      gchar *filename;
-
-      filename = file_utils_uri_to_utf8_filename (uri);
-
-      g_message (_("Opening '%s' failed:\n\n%s"),
-                 filename, error->message);
-      g_clear_error (&error);
-
-      g_free (filename);
+      gtk_button_clicked (GTK_BUTTON (view->open_button));
     }
 }
 
@@ -482,8 +217,11 @@ gimp_document_view_drag_file (GtkWidget *widget,
   GimpViewable *viewable = gimp_dnd_get_drag_data (widget);
 
   if (viewable)
-    return g_list_append (NULL,
-                          g_strdup (gimp_object_get_name (GIMP_OBJECT (viewable))));
+    {
+      const gchar *uri = gimp_object_get_name (GIMP_OBJECT (viewable));
+
+      return g_list_append (NULL, g_strdup (uri));
+    }
 
   return NULL;
 }
diff --git a/app/widgets/gimpdocumentview.h b/app/widgets/gimpdocumentview.h
index 17ec84e846..c49d169334 100644
--- a/app/widgets/gimpdocumentview.h
+++ b/app/widgets/gimpdocumentview.h
@@ -26,11 +26,6 @@
 #include "gimpcontainereditor.h"
 
 
-typedef void (* GimpFileOpenDialogFunc) (Gimp        *gimp,
-                                         const gchar *uri,
-                                         GtkWidget   *parent);
-
-
 #define GIMP_TYPE_DOCUMENT_VIEW            (gimp_document_view_get_type ())
 #define GIMP_DOCUMENT_VIEW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentView))
 #define GIMP_DOCUMENT_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DOCUMENT_VIEW, GimpDocumentViewClass))
@@ -43,13 +38,11 @@ typedef struct _GimpDocumentViewClass  GimpDocumentViewClass;
 
 struct _GimpDocumentView
 {
-  GimpContainerEditor     parent_instance;
+  GimpContainerEditor  parent_instance;
 
-  GimpFileOpenDialogFunc  file_open_dialog_func;
-
-  GtkWidget              *open_button;
-  GtkWidget              *remove_button;
-  GtkWidget              *refresh_button;
+  GtkWidget           *open_button;
+  GtkWidget           *remove_button;
+  GtkWidget           *refresh_button;
 };
 
 struct _GimpDocumentViewClass
@@ -60,13 +53,12 @@ struct _GimpDocumentViewClass
 
 GType       gimp_document_view_get_type (void) G_GNUC_CONST;
 
-GtkWidget * gimp_document_view_new      (GimpViewType            view_type,
-                                         GimpContainer          *container,
-                                         GimpContext            *context,
-                                         gint                    preview_size,
-                                         gint                    preview_border_width,
-                                         GimpFileOpenDialogFunc  file_open_dialog_func,
-                                         GimpMenuFactory        *menu_factory);
+GtkWidget * gimp_document_view_new      (GimpViewType     view_type,
+                                         GimpContainer   *container,
+                                         GimpContext     *context,
+                                         gint             preview_size,
+                                         gint             preview_border_width,
+                                         GimpMenuFactory *menu_factory);
 
 
 #endif  /*  __GIMP_DOCUMENT_VIEW_H__  */
diff --git a/app/widgets/gimpeditor.c b/app/widgets/gimpeditor.c
index bd3a930f57..49cba950d7 100644
--- a/app/widgets/gimpeditor.c
+++ b/app/widgets/gimpeditor.c
@@ -2,7 +2,7 @@
  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  *
  * gimpeditor.c
- * Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
+ * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -40,10 +40,31 @@
 #define DEFAULT_BUTTON_ICON_SIZE GTK_ICON_SIZE_MENU
 
 
+enum
+{
+  PROP_0,
+  PROP_MENU_FACTORY,
+  PROP_MENU_IDENTIFIER,
+  PROP_UI_PATH,
+  PROP_POPUP_DATA
+};
+
+
 static void        gimp_editor_class_init        (GimpEditorClass *klass);
 static void        gimp_editor_init              (GimpEditor      *editor);
 static void        gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface);
 
+static GObject   * gimp_editor_constructor       (GType            type,
+                                                  guint            n_params,
+                                                  GObjectConstructParam *params);
+static void        gimp_editor_set_property      (GObject         *object,
+                                                  guint            property_id,
+                                                  const GValue    *value,
+                                                  GParamSpec      *pspec);
+static void        gimp_editor_get_property      (GObject         *object,
+                                                  guint            property_id,
+                                                  GValue          *value,
+                                                  GParamSpec      *pspec);
 static void        gimp_editor_destroy           (GtkObject       *object);
 static void        gimp_editor_style_set         (GtkWidget       *widget,
                                                   GtkStyle        *prev_style);
@@ -98,17 +119,46 @@ gimp_editor_get_type (void)
 static void
 gimp_editor_class_init (GimpEditorClass *klass)
 {
-  GtkObjectClass *object_class;
-  GtkWidgetClass *widget_class;
-
-  object_class = GTK_OBJECT_CLASS (klass);
-  widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass   *object_class     = G_OBJECT_CLASS (klass);
+  GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class     = GTK_WIDGET_CLASS (klass);
 
   parent_class = g_type_class_peek_parent (klass);
 
-  object_class->destroy   = gimp_editor_destroy;
+  object_class->constructor  = gimp_editor_constructor;
+  object_class->set_property = gimp_editor_set_property;
+  object_class->get_property = gimp_editor_get_property;
 
-  widget_class->style_set = gimp_editor_style_set;
+  gtk_object_class->destroy  = gimp_editor_destroy;
+
+  widget_class->style_set    = gimp_editor_style_set;
+
+  g_object_class_install_property (object_class, PROP_MENU_FACTORY,
+                                   g_param_spec_object ("menu-factory",
+                                                        NULL, NULL,
+                                                        GIMP_TYPE_MENU_FACTORY,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class, PROP_MENU_IDENTIFIER,
+                                   g_param_spec_string ("menu-identifier",
+                                                        NULL, NULL,
+                                                        NULL,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class, PROP_UI_PATH,
+                                   g_param_spec_string ("ui-path",
+                                                        NULL, NULL,
+                                                        NULL,
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT_ONLY));
+
+  g_object_class_install_property (object_class, PROP_POPUP_DATA,
+                                   g_param_spec_pointer ("popup-data",
+                                                         NULL, NULL,
+                                                         G_PARAM_READWRITE |
+                                                         G_PARAM_CONSTRUCT_ONLY));
 
   gtk_widget_class_install_style_property (widget_class,
                                            g_param_spec_int ("content_spacing",
@@ -137,11 +187,12 @@ gimp_editor_class_init (GimpEditorClass *klass)
 static void
 gimp_editor_init (GimpEditor *editor)
 {
-  editor->menu_factory = NULL;
-  editor->ui_manager   = NULL;
-  editor->ui_path      = NULL;
-  editor->popup_data   = NULL;
-  editor->button_box   = NULL;
+  editor->menu_factory    = NULL;
+  editor->menu_identifier = NULL;
+  editor->ui_manager      = NULL;
+  editor->ui_path         = NULL;
+  editor->popup_data      = editor;
+  editor->button_box      = NULL;
 }
 
 static void
@@ -150,11 +201,106 @@ gimp_editor_docked_iface_init (GimpDockedInterface *docked_iface)
   docked_iface->get_menu = gimp_editor_get_menu;
 }
 
+static GObject *
+gimp_editor_constructor (GType                  type,
+                         guint                  n_params,
+                         GObjectConstructParam *params)
+{
+  GObject    *object;
+  GimpEditor *editor;
+
+  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
+
+  editor = GIMP_EDITOR (object);
+
+  if (! editor->popup_data)
+    editor->popup_data = editor;
+
+  if (editor->menu_factory && editor->menu_identifier)
+    {
+      editor->ui_manager =
+        gimp_menu_factory_manager_new (editor->menu_factory,
+                                       editor->menu_identifier,
+                                       editor->popup_data,
+                                       FALSE);
+    }
+
+  return object;
+}
+
+static void
+gimp_editor_set_property (GObject      *object,
+                          guint         property_id,
+                          const GValue *value,
+                          GParamSpec   *pspec)
+{
+  GimpEditor *editor = GIMP_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_MENU_FACTORY:
+      editor->menu_factory = (GimpMenuFactory *) g_value_dup_object (value);
+      break;
+    case PROP_MENU_IDENTIFIER:
+      editor->menu_identifier = g_value_dup_string (value);
+      break;
+    case PROP_UI_PATH:
+      editor->ui_path = g_value_dup_string (value);
+      break;
+    case PROP_POPUP_DATA:
+      editor->popup_data = g_value_get_pointer (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_editor_get_property (GObject    *object,
+                          guint       property_id,
+                          GValue     *value,
+                          GParamSpec *pspec)
+{
+  GimpEditor *editor = GIMP_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_MENU_FACTORY:
+      g_value_set_object (value, editor->menu_factory);
+      break;
+    case PROP_MENU_IDENTIFIER:
+      g_value_set_string (value, editor->menu_identifier);
+      break;
+    case PROP_UI_PATH:
+      g_value_set_string (value, editor->ui_path);
+      break;
+    case PROP_POPUP_DATA:
+      g_value_set_pointer (value, editor->popup_data);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
 static void
 gimp_editor_destroy (GtkObject *object)
 {
   GimpEditor *editor = GIMP_EDITOR (object);
 
+  if (editor->menu_factory)
+    {
+      g_object_unref (editor->menu_factory);
+      editor->menu_factory = NULL;
+    }
+
+  if (editor->menu_identifier)
+    {
+      g_free (editor->menu_identifier);
+      editor->menu_identifier = NULL;
+    }
+
   if (editor->ui_manager)
     {
       g_object_unref (editor->ui_manager);
@@ -216,21 +362,24 @@ gimp_editor_create_menu (GimpEditor      *editor,
                          GimpMenuFactory *menu_factory,
                          const gchar     *menu_identifier,
                          const gchar     *ui_path,
-                         gpointer         callback_data)
+                         gpointer         popup_data)
 {
   g_return_if_fail (GIMP_IS_EDITOR (editor));
   g_return_if_fail (GIMP_IS_MENU_FACTORY (menu_factory));
   g_return_if_fail (menu_identifier != NULL);
   g_return_if_fail (ui_path != NULL);
 
-  editor->menu_factory = menu_factory;
+  if (editor->menu_factory)
+    g_object_unref (editor->menu_factory);
+
+  editor->menu_factory = g_object_ref (menu_factory);
 
   if (editor->ui_manager)
     g_object_unref (editor->ui_manager);
 
   editor->ui_manager = gimp_menu_factory_manager_new (menu_factory,
                                                       menu_identifier,
-                                                      callback_data,
+                                                      popup_data,
                                                       FALSE);
 
   if (editor->ui_path)
@@ -238,7 +387,7 @@ gimp_editor_create_menu (GimpEditor      *editor,
 
   editor->ui_path = g_strdup (ui_path);
 
-  editor->popup_data = callback_data;
+  editor->popup_data = popup_data;
 }
 
 GtkWidget *
@@ -328,10 +477,47 @@ gimp_editor_add_stock_box (GimpEditor  *editor,
   return first_button;
 }
 
+typedef struct _ExtendedAction ExtendedAction;
+
+struct _ExtendedAction
+{
+  GdkModifierType  mod_mask;
+  GtkAction       *action;
+};
+
+static void
+gimp_editor_button_extended_actions_free (GList *list)
+{
+  g_list_foreach (list, (GFunc) g_free, NULL);
+  g_list_free (list);
+}
+
+static void
+gimp_editor_button_extended_clicked (GtkWidget       *button,
+                                     GdkModifierType  mask,
+                                     gpointer         data)
+{
+  GList *extended = g_object_get_data (G_OBJECT (button), "extended-actions");
+  GList *list;
+
+  for (list = extended; list; list = g_list_next (list))
+    {
+      ExtendedAction *ext = list->data;
+
+      if ((ext->mod_mask & mask) == ext->mod_mask &&
+          gtk_action_get_sensitive (ext->action))
+        {
+          gtk_action_activate (ext->action);
+          break;
+        }
+    }
+}
+
 GtkWidget *
 gimp_editor_add_action_button (GimpEditor  *editor,
                                const gchar *group_name,
-                               const gchar *action_name)
+                               const gchar *action_name,
+                               ...)
 {
   GimpActionGroup *group;
   GtkAction       *action;
@@ -342,6 +528,8 @@ gimp_editor_add_action_button (GimpEditor  *editor,
   gchar           *stock_id;
   gchar           *tooltip;
   const gchar     *help_id;
+  GList           *extended = NULL;
+  va_list          args;
 
   g_return_val_if_fail (GIMP_IS_EDITOR (editor), NULL);
   g_return_val_if_fail (action_name != NULL, NULL);
@@ -373,13 +561,6 @@ gimp_editor_add_action_button (GimpEditor  *editor,
   if (tooltip || help_id)
     gimp_help_set_help_data (button, tooltip, help_id);
 
-#if 0
-  if (extended_callback)
-    g_signal_connect (button, "extended_clicked",
-		      extended_callback,
-		      callback_data);
-#endif
-
   old_child = gtk_bin_get_child (GTK_BIN (button));
 
   if (old_child)
@@ -392,6 +573,44 @@ gimp_editor_add_action_button (GimpEditor  *editor,
   g_free (stock_id);
   g_free (tooltip);
 
+  va_start (args, action_name);
+
+  action_name = va_arg (args, const gchar *);
+
+  while (action_name)
+    {
+      GdkModifierType mod_mask;
+
+      mod_mask = va_arg (args, GdkModifierType);
+
+      action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
+                                            action_name);
+
+      if (action && mod_mask)
+        {
+          ExtendedAction *ext = g_new0 (ExtendedAction, 1);
+
+          ext->mod_mask = mod_mask;
+          ext->action   = action;
+
+          extended = g_list_append (extended, ext);
+        }
+
+      action_name = va_arg (args, const gchar *);
+    }
+
+  va_end (args);
+
+  if (extended)
+    {
+      g_object_set_data_full (G_OBJECT (button), "extended-actions", extended,
+                              (GDestroyNotify) gimp_editor_button_extended_actions_free);
+
+      g_signal_connect (button, "extended_clicked",
+                        G_CALLBACK (gimp_editor_button_extended_clicked),
+                        NULL);
+    }
+
   return button;
 }
 
diff --git a/app/widgets/gimpeditor.h b/app/widgets/gimpeditor.h
index 5d92ec699a..23e5b772e9 100644
--- a/app/widgets/gimpeditor.h
+++ b/app/widgets/gimpeditor.h
@@ -41,6 +41,7 @@ struct _GimpEditor
   GtkVBox          parent_instance;
 
   GimpMenuFactory *menu_factory;
+  gchar           *menu_identifier;
   GimpUIManager   *ui_manager;
   gchar           *ui_path;
   gpointer         popup_data;
@@ -62,7 +63,7 @@ void        gimp_editor_create_menu       (GimpEditor      *editor,
                                            GimpMenuFactory *menu_factory,
                                            const gchar     *menu_identifier,
                                            const gchar     *ui_path,
-                                           gpointer         callback_data);
+                                           gpointer         popup_data);
 
 GtkWidget * gimp_editor_add_button        (GimpEditor      *editor,
                                            const gchar     *stock_id,
@@ -79,7 +80,8 @@ GtkWidget * gimp_editor_add_stock_box     (GimpEditor      *editor,
 
 GtkWidget * gimp_editor_add_action_button (GimpEditor      *editor,
                                            const gchar     *group_name,
-                                           const gchar     *action_name);
+                                           const gchar     *action_name,
+                                           ...);
 
 void        gimp_editor_set_box_style (GimpEditor      *editor,
                                        GtkBox          *box);
diff --git a/app/widgets/gimpfontview.c b/app/widgets/gimpfontview.c
index e877f6660a..eb8c7bb14b 100644
--- a/app/widgets/gimpfontview.c
+++ b/app/widgets/gimpfontview.c
@@ -41,8 +41,6 @@
 static void   gimp_font_view_class_init    (GimpFontViewClass   *klass);
 static void   gimp_font_view_init          (GimpFontView        *view);
 
-static void   gimp_font_view_select_item   (GimpContainerEditor *editor,
-                                            GimpViewable        *viewable);
 static void   gimp_font_view_activate_item (GimpContainerEditor *editor,
                                             GimpViewable        *viewable);
 
@@ -85,7 +83,6 @@ gimp_font_view_class_init (GimpFontViewClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
-  editor_class->select_item   = gimp_font_view_select_item;
   editor_class->activate_item = gimp_font_view_activate_item;
 }
 
@@ -124,23 +121,13 @@ gimp_font_view_new (GimpViewType     view_type,
 
   font_view->refresh_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "fonts",
-                                   "fonts-refresh");
+                                   "fonts-refresh", NULL);
 
   gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
 
   return GTK_WIDGET (font_view);
 }
 
-static void
-gimp_font_view_select_item (GimpContainerEditor *editor,
-                            GimpViewable        *viewable)
-{
-  if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
-    GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
-
-  gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
-}
-
 static void
 gimp_font_view_activate_item (GimpContainerEditor *editor,
 				GimpViewable        *viewable)
diff --git a/app/widgets/gimpimageeditor.c b/app/widgets/gimpimageeditor.c
index 4a928cb614..50da5aaef8 100644
--- a/app/widgets/gimpimageeditor.c
+++ b/app/widgets/gimpimageeditor.c
@@ -27,6 +27,7 @@
 
 #include "gimpdocked.h"
 #include "gimpimageeditor.h"
+#include "gimpuimanager.h"
 
 
 static void   gimp_image_editor_class_init     (GimpImageEditorClass *klass);
@@ -37,10 +38,12 @@ static void   gimp_image_editor_set_docked_context (GimpDocked       *docked,
                                                     GimpContext      *context,
                                                     GimpContext      *prev_context);
 
-static void   gimp_image_editor_destroy        (GtkObject            *object);
+static void   gimp_image_editor_destroy            (GtkObject        *object);
+static void   gimp_image_editor_real_set_image     (GimpImageEditor  *editor,
+                                                    GimpImage        *gimage);
 
-static void   gimp_image_editor_real_set_image (GimpImageEditor      *editor,
-                                                GimpImage            *gimage);
+static void   gimp_image_editor_image_flush        (GimpImage        *gimage,
+                                                    GimpImageEditor  *editor);
 
 
 static GimpEditorClass *parent_class = NULL;
@@ -86,9 +89,7 @@ gimp_image_editor_get_type (void)
 static void
 gimp_image_editor_class_init (GimpImageEditorClass *klass)
 {
-  GtkObjectClass *object_class;
-
-  object_class = GTK_OBJECT_CLASS (klass);
+  GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 
   parent_class = g_type_class_peek_parent (klass);
 
@@ -147,9 +148,7 @@ gimp_image_editor_set_docked_context (GimpDocked  *docked,
 static void
 gimp_image_editor_destroy (GtkObject *object)
 {
-  GimpImageEditor *editor;
-
-  editor = GIMP_IMAGE_EDITOR (object);
+  GimpImageEditor *editor = GIMP_IMAGE_EDITOR (object);
 
   if (editor->gimage)
     gimp_image_editor_set_image (editor, NULL);
@@ -161,8 +160,18 @@ static void
 gimp_image_editor_real_set_image (GimpImageEditor *editor,
                                   GimpImage       *gimage)
 {
+  if (editor->gimage)
+    g_signal_handlers_disconnect_by_func (editor->gimage,
+                                          gimp_image_editor_image_flush,
+                                          editor);
+
   editor->gimage = gimage;
 
+  if (editor->gimage)
+    g_signal_connect (editor->gimage, "flush",
+                      G_CALLBACK (gimp_image_editor_image_flush),
+                      editor);
+
   gtk_widget_set_sensitive (GTK_WIDGET (editor), gimage != NULL);
 }
 
@@ -174,10 +183,26 @@ gimp_image_editor_set_image (GimpImageEditor *editor,
                              GimpImage       *gimage)
 {
   g_return_if_fail (GIMP_IS_IMAGE_EDITOR (editor));
-  g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage));
+  g_return_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage));
 
-  if (gimage == editor->gimage)
-    return;
+  if (gimage != editor->gimage)
+    {
+      GIMP_IMAGE_EDITOR_GET_CLASS (editor)->set_image (editor, gimage);
 
-  GIMP_IMAGE_EDITOR_GET_CLASS (editor)->set_image (editor, gimage);
+      if (GIMP_EDITOR (editor)->ui_manager)
+        gimp_ui_manager_update (GIMP_EDITOR (editor)->ui_manager,
+                                GIMP_EDITOR (editor)->popup_data);
+    }
+}
+
+
+/*  private functions  */
+
+static void
+gimp_image_editor_image_flush (GimpImage       *gimage,
+                               GimpImageEditor *editor)
+{
+  if (GIMP_EDITOR (editor)->ui_manager)
+    gimp_ui_manager_update (GIMP_EDITOR (editor)->ui_manager,
+                            GIMP_EDITOR (editor)->popup_data);
 }
diff --git a/app/widgets/gimpimageview.c b/app/widgets/gimpimageview.c
index 7ea843349c..4320275229 100644
--- a/app/widgets/gimpimageview.c
+++ b/app/widgets/gimpimageview.c
@@ -42,8 +42,6 @@
 static void   gimp_image_view_class_init    (GimpImageViewClass  *klass);
 static void   gimp_image_view_init          (GimpImageView       *view);
 
-static void   gimp_image_view_select_item   (GimpContainerEditor *editor,
-                                             GimpViewable        *viewable);
 static void   gimp_image_view_activate_item (GimpContainerEditor *editor,
                                              GimpViewable        *viewable);
 
@@ -86,7 +84,6 @@ gimp_image_view_class_init (GimpImageViewClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
-  editor_class->select_item   = gimp_image_view_select_item;
   editor_class->activate_item = gimp_image_view_activate_item;
 }
 
@@ -127,15 +124,15 @@ gimp_image_view_new (GimpViewType     view_type,
 
   image_view->raise_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images",
-                                   "images-raise-views");
+                                   "images-raise-views", NULL);
 
   image_view->new_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images",
-                                   "images-new-view");
+                                   "images-new-view", NULL);
 
   image_view->delete_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "images",
-                                   "images-delete");
+                                   "images-delete", NULL);
 
   gimp_container_view_enable_dnd (editor->view,
 				  GTK_BUTTON (image_view->raise_button),
@@ -153,16 +150,6 @@ gimp_image_view_new (GimpViewType     view_type,
   return GTK_WIDGET (image_view);
 }
 
-static void
-gimp_image_view_select_item (GimpContainerEditor *editor,
-                             GimpViewable        *viewable)
-{
-  if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
-    GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
-
-  gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
-}
-
 static void
 gimp_image_view_activate_item (GimpContainerEditor *editor,
                                GimpViewable        *viewable)
diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c
index 64fae33964..7f4a378d8b 100644
--- a/app/widgets/gimpitemtreeview.c
+++ b/app/widgets/gimpitemtreeview.c
@@ -625,7 +625,7 @@ gimp_item_tree_view_new (gint                  preview_size,
                          GimpActivateItemFunc  activate_item_func,
                          GimpMenuFactory      *menu_factory,
                          const gchar          *menu_identifier,
-                         const gchar          *ui_identifier)
+                         const gchar          *ui_path)
 {
   GimpItemTreeView *item_view;
   GType             view_type;
@@ -642,7 +642,7 @@ gimp_item_tree_view_new (gint                  preview_size,
   g_return_val_if_fail (activate_item_func != NULL, NULL);
   g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
   g_return_val_if_fail (menu_identifier != NULL, NULL);
-  g_return_val_if_fail (ui_identifier != NULL, NULL);
+  g_return_val_if_fail (ui_path != NULL, NULL);
 
   if (item_type == GIMP_TYPE_LAYER)
     {
@@ -664,9 +664,12 @@ gimp_item_tree_view_new (gint                  preview_size,
     }
 
   item_view = g_object_new (view_type,
-                            "reorderable", TRUE,
-                            "item-type",   item_type,
-                            "signal-name", signal_name,
+                            "reorderable",     TRUE,
+                            "menu-factory",    menu_factory,
+                            "menu-identifier", menu_identifier,
+                            "ui-path",         ui_path,
+                            "item-type",       item_type,
+                            "signal-name",     signal_name,
                             NULL);
 
   gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (item_view),
@@ -676,10 +679,6 @@ gimp_item_tree_view_new (gint                  preview_size,
   item_view->new_item_func      = new_item_func;
   item_view->activate_item_func = activate_item_func;
 
-  gimp_editor_create_menu (GIMP_EDITOR (item_view),
-                           menu_factory, menu_identifier, ui_identifier,
-                           item_view);
-
   gimp_item_tree_view_set_image (item_view, gimage);
 
   return GTK_WIDGET (item_view);
@@ -734,6 +733,10 @@ gimp_item_tree_view_real_set_image (GimpItemTreeView *view,
 
       gimp_item_tree_view_item_changed (view->gimage, view);
     }
+  else
+    {
+      gimp_ui_manager_update (GIMP_EDITOR (view)->ui_manager, view);
+    }
 
   gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL));
 }
@@ -856,6 +859,8 @@ gimp_item_tree_view_select_item (GimpContainerView *view,
   gtk_widget_set_sensitive (tree_view->duplicate_button, duplicate_sensitive);
   gtk_widget_set_sensitive (tree_view->delete_button,    delete_sensitive);
 
+  gimp_ui_manager_update (GIMP_EDITOR (tree_view)->ui_manager, tree_view);
+
   return success;
 }
 
diff --git a/app/widgets/gimplayertreeview.c b/app/widgets/gimplayertreeview.c
index 526c687631..abefe19e72 100644
--- a/app/widgets/gimplayertreeview.c
+++ b/app/widgets/gimplayertreeview.c
@@ -45,6 +45,7 @@
 #include "gimphelp-ids.h"
 #include "gimplayertreeview.h"
 #include "gimppreviewrenderer.h"
+#include "gimpuimanager.h"
 #include "gimpwidgets-constructors.h"
 
 #include "gimp-intl.h"
@@ -89,9 +90,6 @@ static void   gimp_layer_tree_view_floating_selection_changed
                                                   (GimpImage           *gimage,
                                                    GimpLayerTreeView   *view);
 
-static void   gimp_layer_tree_view_anchor_clicked (GtkWidget           *widget,
-						   GimpLayerTreeView   *view);
-
 static void   gimp_layer_tree_view_paint_mode_menu_callback
                                                   (GtkWidget           *widget,
 						   GimpLayerTreeView   *view);
@@ -319,25 +317,7 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view)
 
   gtk_widget_hide (GIMP_ITEM_TREE_VIEW (view)->edit_button);
 
-  /*  Anchor button  */
-
-  view->anchor_button =
-    gimp_editor_add_button (GIMP_EDITOR (view),
-                            GIMP_STOCK_ANCHOR, _("Anchor Floating Layer"),
-                            GIMP_HELP_LAYER_ANCHOR,
-                            G_CALLBACK (gimp_layer_tree_view_anchor_clicked),
-                            NULL,
-                            view);
-
-  gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (view)->button_box),
-			 view->anchor_button, 5);
-
-  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (view),
-				  GTK_BUTTON (view->anchor_button),
-				  GIMP_TYPE_LAYER);
-
   gtk_widget_set_sensitive (view->options_box,   FALSE);
-  gtk_widget_set_sensitive (view->anchor_button, FALSE);
 
   view->italic_attrs = pango_attr_list_new ();
   attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
@@ -404,6 +384,17 @@ gimp_layer_tree_view_constructor (GType                  type,
                     G_CALLBACK (gimp_layer_tree_view_mask_clicked),
                     layer_view);
 
+  layer_view->anchor_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (layer_view), "layers",
+                                   "layers-anchor", NULL);
+
+  gtk_box_reorder_child (GTK_BOX (GIMP_EDITOR (layer_view)->button_box),
+			 layer_view->anchor_button, 5);
+
+  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (layer_view),
+				  GTK_BUTTON (layer_view->anchor_button),
+				  GIMP_TYPE_LAYER);
+
   return object;
 }
 
@@ -559,7 +550,6 @@ gimp_layer_tree_view_select_item (GimpContainerView *view,
   GimpItemTreeView  *item_view         = GIMP_ITEM_TREE_VIEW (view);
   GimpLayerTreeView *layer_view        = GIMP_LAYER_TREE_VIEW (view);
   gboolean           options_sensitive = FALSE;
-  gboolean           anchor_sensitive  = FALSE;
   gboolean           raise_sensitive   = FALSE;
   gboolean           success;
 
@@ -578,8 +568,6 @@ gimp_layer_tree_view_select_item (GimpContainerView *view,
 
       if (! success || gimp_layer_is_floating_sel (GIMP_LAYER (item)))
 	{
-	  anchor_sensitive = TRUE;
-
 	  gtk_widget_set_sensitive (item_view->edit_button,      FALSE);
 	  gtk_widget_set_sensitive (item_view->lower_button,     FALSE);
 	  gtk_widget_set_sensitive (item_view->duplicate_button, FALSE);
@@ -598,9 +586,8 @@ gimp_layer_tree_view_select_item (GimpContainerView *view,
 	}
     }
 
-  gtk_widget_set_sensitive (layer_view->options_box,   options_sensitive);
-  gtk_widget_set_sensitive (item_view->raise_button,   raise_sensitive);
-  gtk_widget_set_sensitive (layer_view->anchor_button, anchor_sensitive);
+  gtk_widget_set_sensitive (layer_view->options_box, options_sensitive);
+  gtk_widget_set_sensitive (item_view->raise_button, raise_sensitive);
 
   return success;
 }
@@ -750,25 +737,6 @@ gimp_layer_tree_view_floating_selection_changed (GimpImage         *gimage,
     }
 }
 
-static void
-gimp_layer_tree_view_anchor_clicked (GtkWidget         *widget,
-				     GimpLayerTreeView *view)
-{
-  GimpImage *gimage;
-  GimpLayer *layer;
-
-  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
-
-  layer = (GimpLayer *)
-    GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
-
-  if (layer && gimp_layer_is_floating_sel (layer))
-    {
-      floating_sel_anchor (layer);
-      gimp_image_flush (gimage);
-    }
-}
-
 
 /*  Paint Mode, Opacity and Preserve trans. callbacks  */
 
diff --git a/app/widgets/gimpselectioneditor.c b/app/widgets/gimpselectioneditor.c
index cec0391151..8fc393c0ce 100644
--- a/app/widgets/gimpselectioneditor.c
+++ b/app/widgets/gimpselectioneditor.c
@@ -45,6 +45,7 @@
 #include "gimpselectioneditor.h"
 #include "gimpdnd.h"
 #include "gimphelp-ids.h"
+#include "gimpmenufactory.h"
 #include "gimppreview.h"
 #include "gimppreviewrenderer.h"
 #include "gimpwidgets-utils.h"
@@ -55,25 +56,13 @@
 static void   gimp_selection_editor_class_init (GimpSelectionEditorClass *klass);
 static void   gimp_selection_editor_init       (GimpSelectionEditor      *selection_editor);
 
+static GObject * gimp_selection_editor_constructor (GType                type,
+                                                    guint                n_params,
+                                                    GObjectConstructParam *params);
+
 static void   gimp_selection_editor_set_image      (GimpImageEditor     *editor,
                                                     GimpImage           *gimage);
 
-static void   gimp_selection_editor_invert_clicked (GtkWidget           *widget,
-                                                    GimpImageEditor     *editor);
-static void   gimp_selection_editor_all_clicked    (GtkWidget           *widget,
-                                                    GimpImageEditor     *editor);
-static void   gimp_selection_editor_none_clicked   (GtkWidget           *widget,
-                                                    GimpImageEditor     *editor);
-static void   gimp_selection_editor_save_clicked   (GtkWidget           *widget,
-                                                    GimpImageEditor     *editor);
-static void   gimp_selection_editor_path_clicked   (GtkWidget           *widget,
-                                                    GimpImageEditor     *editor);
-static void   gimp_selection_editor_path_extended_clicked (GtkWidget    *widget,
-                                                    guint                state,
-                                                    GimpImageEditor     *editor);
-static void   gimp_selection_editor_stroke_clicked (GtkWidget           *widget,
-                                                    GimpImageEditor     *editor);
-
 static gboolean gimp_selection_preview_button_press(GtkWidget           *widget,
                                                     GdkEventButton      *bevent,
                                                     GimpSelectionEditor *editor);
@@ -119,104 +108,98 @@ gimp_selection_editor_get_type (void)
 static void
 gimp_selection_editor_class_init (GimpSelectionEditorClass* klass)
 {
-  GimpImageEditorClass *image_editor_class;
-
-  image_editor_class = GIMP_IMAGE_EDITOR_CLASS (klass);
+  GObjectClass         *object_class       = G_OBJECT_CLASS (klass);
+  GimpImageEditorClass *image_editor_class = GIMP_IMAGE_EDITOR_CLASS (klass);
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->constructor     = gimp_selection_editor_constructor;
+
   image_editor_class->set_image = gimp_selection_editor_set_image;
 }
 
 static void
-gimp_selection_editor_init (GimpSelectionEditor *selection_editor)
+gimp_selection_editor_init (GimpSelectionEditor *editor)
 {
   GtkWidget *frame;
-  gchar     *str;
 
   frame = gtk_frame_new (NULL);
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
-  gtk_box_pack_start (GTK_BOX (selection_editor), frame, TRUE, TRUE, 0);
+  gtk_box_pack_start (GTK_BOX (editor), frame, TRUE, TRUE, 0);
   gtk_widget_show (frame);
 
-  selection_editor->selection_to_vectors_func = NULL;
-
-  selection_editor->preview = gimp_preview_new_by_types (GIMP_TYPE_PREVIEW,
-                                                         GIMP_TYPE_SELECTION,
-                                                         GIMP_PREVIEW_SIZE_HUGE,
-                                                         0, TRUE);
-  gtk_widget_set_size_request (selection_editor->preview,
+  editor->preview = gimp_preview_new_by_types (GIMP_TYPE_PREVIEW,
+                                               GIMP_TYPE_SELECTION,
+                                               GIMP_PREVIEW_SIZE_HUGE,
+                                               0, TRUE);
+  gimp_preview_renderer_set_background (GIMP_PREVIEW (editor->preview)->renderer,
+                                        GIMP_STOCK_TEXTURE);
+  gtk_widget_set_size_request (editor->preview,
                                GIMP_PREVIEW_SIZE_HUGE, GIMP_PREVIEW_SIZE_HUGE);
-  gimp_preview_set_expand (GIMP_PREVIEW (selection_editor->preview), TRUE);
-  gtk_container_add (GTK_CONTAINER (frame), selection_editor->preview);
-  gtk_widget_show (selection_editor->preview);
+  gimp_preview_set_expand (GIMP_PREVIEW (editor->preview), TRUE);
+  gtk_container_add (GTK_CONTAINER (frame), editor->preview);
+  gtk_widget_show (editor->preview);
 
-  g_signal_connect (selection_editor->preview, "button_press_event",
+  g_signal_connect (editor->preview, "button_press_event",
                     G_CALLBACK (gimp_selection_preview_button_press),
-                    selection_editor);
+                    editor);
 
-  gimp_dnd_color_dest_add (selection_editor->preview,
+  gimp_dnd_color_dest_add (editor->preview,
                            gimp_selection_editor_drop_color,
-                           selection_editor);
+                           editor);
 
-  selection_editor->all_button =
-    gimp_editor_add_button (GIMP_EDITOR (selection_editor),
-                            GIMP_STOCK_SELECTION_ALL, _("Select All"),
-                            GIMP_HELP_SELECTION_ALL,
-                            G_CALLBACK (gimp_selection_editor_all_clicked),
-                            NULL,
-                            selection_editor);
+  gtk_widget_set_sensitive (GTK_WIDGET (editor), FALSE);
+}
 
-  selection_editor->none_button =
-    gimp_editor_add_button (GIMP_EDITOR (selection_editor),
-                            GIMP_STOCK_SELECTION_NONE, _("Select None"),
-                            GIMP_HELP_SELECTION_NONE,
-                            G_CALLBACK (gimp_selection_editor_none_clicked),
-                            NULL,
-                            selection_editor);
+static GObject *
+gimp_selection_editor_constructor (GType                  type,
+                                   guint                  n_params,
+                                   GObjectConstructParam *params)
+{
+  GObject             *object;
+  GimpSelectionEditor *editor;
+  gchar               *str;
 
-  selection_editor->invert_button =
-    gimp_editor_add_button (GIMP_EDITOR (selection_editor),
-                            GIMP_STOCK_INVERT, _("Invert Selection"),
-                            GIMP_HELP_SELECTION_INVERT,
-                            G_CALLBACK (gimp_selection_editor_invert_clicked),
-                            NULL,
-                            selection_editor);
+  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
 
-  selection_editor->save_button =
-    gimp_editor_add_button (GIMP_EDITOR (selection_editor),
-                            GIMP_STOCK_SELECTION_TO_CHANNEL,
-                            _("Save Selection to Channel"),
-                            GIMP_HELP_SELECTION_TO_CHANNEL,
-                            G_CALLBACK (gimp_selection_editor_save_clicked),
-                            NULL,
-                            selection_editor);
+  editor = GIMP_SELECTION_EDITOR (object);
 
-  str = g_strdup_printf (_("Selection to Path\n"
-                           "%s  Advanced Options"),
+  editor->all_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
+                                   "select-all", NULL);
+
+  editor->none_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
+                                   "select-none", NULL);
+
+  editor->invert_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
+                                   "select-invert", NULL);
+
+  editor->save_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
+                                   "select-save", NULL);
+
+  str = g_strdup_printf (_("Selection to path\n"
+                           "%s  Advanced options"),
                          gimp_get_mod_name_shift ());
 
-  selection_editor->path_button =
-    gimp_editor_add_button (GIMP_EDITOR (selection_editor),
-                            GIMP_STOCK_SELECTION_TO_PATH, str,
-                            GIMP_HELP_SELECTION_TO_PATH,
-                            G_CALLBACK (gimp_selection_editor_path_clicked),
-                            G_CALLBACK (gimp_selection_editor_path_extended_clicked),
-                            selection_editor);
+  editor->path_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (editor), "vectors",
+                                   "vectors-selection-to-vectors",
+                                   "vectors-selection-to-vectors-advanced",
+                                   GDK_SHIFT_MASK,
+                                   NULL);
+  gimp_help_set_help_data (editor->path_button, str,
+                           GIMP_HELP_SELECTION_TO_PATH);
 
   g_free (str);
 
-  selection_editor->stroke_button =
-    gimp_editor_add_button (GIMP_EDITOR (selection_editor),
-                            GIMP_STOCK_SELECTION_STROKE,
-                            _("Stroke Selection"),
-                            GIMP_HELP_SELECTION_STROKE,
-                            G_CALLBACK (gimp_selection_editor_stroke_clicked),
-                            NULL,
-                            selection_editor);
+  editor->stroke_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (editor), "select",
+                                   "select-stroke", NULL);
 
-
-  gtk_widget_set_sensitive (GTK_WIDGET (selection_editor), FALSE);
+  return object;
 }
 
 static void
@@ -252,20 +235,20 @@ gimp_selection_editor_set_image (GimpImageEditor *image_editor,
 
 /*  public functions  */
 
-#define PREVIEW_WIDTH       256
-#define PREVIEW_HEIGHT      256
-
 GtkWidget *
-gimp_selection_editor_new (GimpImage *gimage)
+gimp_selection_editor_new (GimpImage       *gimage,
+                           GimpMenuFactory *menu_factory)
 {
   GimpSelectionEditor *editor;
 
   g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL);
+  g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
 
-  editor = g_object_new (GIMP_TYPE_SELECTION_EDITOR, NULL);
-
-  gimp_preview_renderer_set_background (GIMP_PREVIEW (editor->preview)->renderer,
-                                        GIMP_STOCK_TEXTURE);
+  editor = g_object_new (GIMP_TYPE_SELECTION_EDITOR,
+                         "menu-factory",    menu_factory,
+                         "menu-identifier", "<SelectionEditor>",
+                         "ui-path",         "/selection-editor-popup",
+                         NULL);
 
   if (gimage)
     gimp_image_editor_set_image (GIMP_IMAGE_EDITOR (editor), gimage);
@@ -273,85 +256,6 @@ gimp_selection_editor_new (GimpImage *gimage)
   return GTK_WIDGET (editor);
 }
 
-static void
-gimp_selection_editor_invert_clicked (GtkWidget       *widget,
-                                      GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      gimp_channel_invert (gimp_image_get_mask (editor->gimage), TRUE);
-      gimp_image_flush (editor->gimage);
-    }
-}
-
-static void
-gimp_selection_editor_all_clicked (GtkWidget       *widget,
-                                   GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      gimp_channel_all (gimp_image_get_mask (editor->gimage), TRUE);
-      gimp_image_flush (editor->gimage);
-    }
-}
-
-static void
-gimp_selection_editor_none_clicked (GtkWidget       *widget,
-                                    GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      gimp_channel_clear (gimp_image_get_mask (editor->gimage), NULL, TRUE);
-      gimp_image_flush (editor->gimage);
-    }
-}
-
-static void
-gimp_selection_editor_save_clicked (GtkWidget       *widget,
-                                    GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      gimp_selection_save (gimp_image_get_mask (editor->gimage));
-    }
-}
-
-static void
-gimp_selection_editor_path_clicked (GtkWidget       *widget,
-                                    GimpImageEditor *editor)
-{
-  gimp_selection_editor_path_extended_clicked (widget, 0, editor);
-}
-
-static void
-gimp_selection_editor_path_extended_clicked (GtkWidget       *widget,
-                                             guint            state,
-                                             GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      GimpSelectionEditor *sel_editor = GIMP_SELECTION_EDITOR (editor);
-
-      if (sel_editor->selection_to_vectors_func)
-        sel_editor->selection_to_vectors_func (editor->gimage,
-                                               (state & GDK_SHIFT_MASK) != 0);
-    }
-}
-
-static void
-gimp_selection_editor_stroke_clicked (GtkWidget       *widget,
-				      GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      GimpSelectionEditor *sel_editor = GIMP_SELECTION_EDITOR (editor);
-
-      if (sel_editor->stroke_item_func)
-        sel_editor->stroke_item_func (GIMP_ITEM (gimp_image_get_mask (editor->gimage)),
-                                      GTK_WIDGET (editor));
-    }
-}
-
 static gboolean
 gimp_selection_preview_button_press (GtkWidget           *widget,
                                      GdkEventButton      *bevent,
diff --git a/app/widgets/gimpselectioneditor.h b/app/widgets/gimpselectioneditor.h
index 49d2252590..98371db37f 100644
--- a/app/widgets/gimpselectioneditor.h
+++ b/app/widgets/gimpselectioneditor.h
@@ -35,19 +35,16 @@ typedef struct _GimpSelectionEditorClass GimpSelectionEditorClass;
 
 struct _GimpSelectionEditor
 {
-  GimpImageEditor             parent_instance;
+  GimpImageEditor  parent_instance;
 
-  GimpStrokeItemFunc          stroke_item_func;
-  GimpSelectionToVectorsFunc  selection_to_vectors_func;
+  GtkWidget       *preview;
 
-  GtkWidget                  *preview;
-
-  GtkWidget                  *all_button;
-  GtkWidget                  *none_button;
-  GtkWidget                  *invert_button;
-  GtkWidget                  *save_button;
-  GtkWidget                  *path_button;
-  GtkWidget                  *stroke_button;
+  GtkWidget       *all_button;
+  GtkWidget       *none_button;
+  GtkWidget       *invert_button;
+  GtkWidget       *save_button;
+  GtkWidget       *path_button;
+  GtkWidget       *stroke_button;
 };
 
 struct _GimpSelectionEditorClass
@@ -58,7 +55,8 @@ struct _GimpSelectionEditorClass
 
 GType       gimp_selection_editor_get_type  (void) G_GNUC_CONST;
 
-GtkWidget * gimp_selection_editor_new       (GimpImage *gimage);
+GtkWidget * gimp_selection_editor_new       (GimpImage       *gimage,
+                                             GimpMenuFactory *menu_factory);
 
 
 #endif /* __GIMP_SELECTION_EDITOR_H__ */
diff --git a/app/widgets/gimptemplateview.c b/app/widgets/gimptemplateview.c
index 36849adc06..7561eab260 100644
--- a/app/widgets/gimptemplateview.c
+++ b/app/widgets/gimptemplateview.c
@@ -49,14 +49,11 @@
 #include "gimp-intl.h"
 
 
-static void   gimp_template_view_class_init (GimpTemplateViewClass *klass);
-static void   gimp_template_view_init       (GimpTemplateView      *view);
+static void   gimp_template_view_class_init     (GimpTemplateViewClass *klass);
+static void   gimp_template_view_init           (GimpTemplateView      *view);
 
-static void   gimp_template_view_select_item    (GimpContainerEditor *editor,
-                                                 GimpViewable        *viewable);
 static void   gimp_template_view_activate_item  (GimpContainerEditor *editor,
                                                  GimpViewable        *viewable);
-
 static void gimp_template_view_tree_name_edited (GtkCellRendererText *cell,
                                                  const gchar         *path_str,
                                                  const gchar         *new_name,
@@ -101,7 +98,6 @@ gimp_template_view_class_init (GimpTemplateViewClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
-  editor_class->select_item   = gimp_template_view_select_item;
   editor_class->activate_item = gimp_template_view_activate_item;
 }
 
@@ -161,23 +157,23 @@ gimp_template_view_new (GimpViewType     view_type,
 
   template_view->create_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
-                                   "templates-create-image");
+                                   "templates-create-image", NULL);
 
   template_view->new_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
-                                   "templates-new");
+                                   "templates-new", NULL);
 
   template_view->duplicate_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
-                                   "templates-duplicate");
+                                   "templates-duplicate", NULL);
 
   template_view->edit_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
-                                   "templates-edit");
+                                   "templates-edit", NULL);
 
   template_view->delete_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "templates",
-                                   "templates-delete");
+                                   "templates-delete", NULL);
 
   gimp_container_view_enable_dnd (editor->view,
 				  GTK_BUTTON (template_view->create_button),
@@ -197,16 +193,6 @@ gimp_template_view_new (GimpViewType     view_type,
   return GTK_WIDGET (template_view);
 }
 
-static void
-gimp_template_view_select_item (GimpContainerEditor *editor,
-                                GimpViewable        *viewable)
-{
-  if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item)
-    GIMP_CONTAINER_EDITOR_CLASS (parent_class)->select_item (editor, viewable);
-
-  gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
-}
-
 static void
 gimp_template_view_activate_item (GimpContainerEditor *editor,
                                   GimpViewable        *viewable)
diff --git a/app/widgets/gimptoolview.c b/app/widgets/gimptoolview.c
index faa7658402..c964596d58 100644
--- a/app/widgets/gimptoolview.c
+++ b/app/widgets/gimptoolview.c
@@ -125,7 +125,7 @@ gimp_tool_view_new (GimpViewType     view_type,
 
   tool_view->reset_button =
     gimp_editor_add_action_button (GIMP_EDITOR (editor->view), "tools",
-                                   "tools-reset");
+                                   "tools-reset", NULL);
 
   gimp_ui_manager_update (GIMP_EDITOR (editor->view)->ui_manager, editor);
 
diff --git a/app/widgets/gimpundoeditor.c b/app/widgets/gimpundoeditor.c
index 06bd6fe417..29440f3e75 100644
--- a/app/widgets/gimpundoeditor.c
+++ b/app/widgets/gimpundoeditor.c
@@ -35,6 +35,7 @@
 #include "gimpcontainertreeview.h"
 #include "gimpcontainerview.h"
 #include "gimphelp-ids.h"
+#include "gimpmenufactory.h"
 #include "gimpundoeditor.h"
 
 #include "gimp-intl.h"
@@ -63,13 +64,6 @@ static void      gimp_undo_editor_set_image      (GimpImageEditor   *editor,
 static void      gimp_undo_editor_fill           (GimpUndoEditor    *editor);
 static void      gimp_undo_editor_clear          (GimpUndoEditor    *editor);
 
-static void      gimp_undo_editor_undo_clicked   (GtkWidget         *widget,
-                                                  GimpImageEditor   *editor);
-static void      gimp_undo_editor_redo_clicked   (GtkWidget         *widget,
-                                                  GimpImageEditor   *editor);
-static void      gimp_undo_editor_clear_clicked  (GtkWidget         *widget,
-                                                  GimpImageEditor   *editor);
-
 static void      gimp_undo_editor_undo_event     (GimpImage         *gimage,
                                                   GimpUndoEvent      event,
                                                   GimpUndo          *undo,
@@ -80,8 +74,6 @@ static void      gimp_undo_editor_select_item    (GimpContainerView *view,
                                                   gpointer           insert_data,
                                                   GimpUndoEditor    *editor);
 
-static void      gimp_undo_editor_update_buttons (GimpUndoEditor    *editor);
-
 
 static GimpImageEditorClass *parent_class = NULL;
 
@@ -140,31 +132,6 @@ gimp_undo_editor_class_init (GimpUndoEditorClass *klass)
 static void
 gimp_undo_editor_init (GimpUndoEditor *undo_editor)
 {
-  undo_editor->container = NULL;
-
-  undo_editor->undo_button =
-    gimp_editor_add_button (GIMP_EDITOR (undo_editor),
-                            GTK_STOCK_UNDO, _("Undo"),
-                            GIMP_HELP_EDIT_UNDO,
-                            G_CALLBACK (gimp_undo_editor_undo_clicked),
-                            NULL,
-                            undo_editor);
-
-  undo_editor->redo_button =
-    gimp_editor_add_button (GIMP_EDITOR (undo_editor),
-                            GTK_STOCK_REDO, _("Redo"),
-                            GIMP_HELP_EDIT_REDO,
-                            G_CALLBACK (gimp_undo_editor_redo_clicked),
-                            NULL,
-                            undo_editor);
-
-  undo_editor->clear_button =
-    gimp_editor_add_button (GIMP_EDITOR (undo_editor),
-                            GTK_STOCK_CLEAR, _("Clear Undo History"),
-                            GIMP_HELP_EDIT_UNDO_CLEAR,
-                            G_CALLBACK (gimp_undo_editor_clear_clicked),
-                            NULL,
-                            undo_editor);
 }
 
 static GObject *
@@ -189,6 +156,18 @@ gimp_undo_editor_constructor (GType                  type,
                     G_CALLBACK (gimp_undo_editor_select_item),
                     undo_editor);
 
+  undo_editor->undo_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (undo_editor), "edit",
+                                   "edit-undo", NULL);
+
+  undo_editor->redo_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (undo_editor), "edit",
+                                   "edit-redo", NULL);
+
+  undo_editor->clear_button =
+    gimp_editor_add_action_button (GIMP_EDITOR (undo_editor), "edit",
+                                   "edit-undo-clear", NULL);
+
   return object;
 }
 
@@ -243,15 +222,20 @@ gimp_undo_editor_set_image (GimpImageEditor *image_editor,
 /*  public functions  */
 
 GtkWidget *
-gimp_undo_editor_new (GimpCoreConfig *config)
+gimp_undo_editor_new (GimpCoreConfig  *config,
+                      GimpMenuFactory *menu_factory)
 {
   g_return_val_if_fail (GIMP_IS_CORE_CONFIG (config), NULL);
+  g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
 
   return g_object_new (GIMP_TYPE_UNDO_EDITOR,
-                       "preview-size", config->undo_preview_size,
+                       "menu-factory",    menu_factory,
+                       "menu-identifier", "<UndoEditor>",
+                       "preview-size",    config->undo_preview_size,
                        NULL);
 }
 
+
 /*  private functions  */
 
 static void
@@ -329,8 +313,6 @@ gimp_undo_editor_fill (GimpUndoEditor *editor)
   g_signal_handlers_unblock_by_func (editor->view,
                                      gimp_undo_editor_select_item,
                                      editor);
-
-  gimp_undo_editor_update_buttons (editor);
 }
 
 static void
@@ -351,66 +333,6 @@ gimp_undo_editor_clear (GimpUndoEditor *editor)
     }
 }
 
-static void
-gimp_undo_editor_undo_clicked (GtkWidget       *widget,
-                               GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      if (gimp_image_undo (editor->gimage))
-        gimp_image_flush (editor->gimage);
-    }
-}
-
-static void
-gimp_undo_editor_redo_clicked (GtkWidget       *widget,
-                               GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      if (gimp_image_redo (editor->gimage))
-        gimp_image_flush (editor->gimage);
-    }
-}
-
-static void
-gimp_undo_editor_clear_callback (GtkWidget *widget,
-                                 gboolean   clear,
-                                 gpointer   data)
-{
-  if (clear)
-    {
-      GimpImage *gimage = data;
-
-      gimp_image_undo_disable (gimage);
-      gimp_image_undo_enable (gimage);
-      gimp_image_flush (gimage);
-    }
-}
-
-static void
-gimp_undo_editor_clear_clicked (GtkWidget       *widget,
-                                GimpImageEditor *editor)
-{
-  if (editor->gimage)
-    {
-      GtkWidget *dialog;
-
-      dialog = gimp_query_boolean_box (_("Clear Undo History"),
-                                       GTK_WIDGET (editor),
-				       gimp_standard_help_func,
-                                       GIMP_HELP_EDIT_UNDO_CLEAR,
-				       GIMP_STOCK_QUESTION,
-				       _("Really clear image's undo history?"),
-				       GTK_STOCK_CLEAR, GTK_STOCK_CANCEL,
-				       G_OBJECT (editor->gimage),
-				       "disconnect",
-				       gimp_undo_editor_clear_callback,
-                                       editor->gimage);
-      gtk_widget_show (dialog);
-    }
-}
-
 static void
 gimp_undo_editor_undo_event (GimpImage      *gimage,
                              GimpUndoEvent   event,
@@ -480,8 +402,6 @@ gimp_undo_editor_undo_event (GimpImage      *gimage,
       gimp_undo_editor_fill (editor);
       break;
     }
-
-  gimp_undo_editor_update_buttons (editor);
 }
 
 static void
@@ -537,20 +457,4 @@ gimp_undo_editor_select_item (GimpContainerView *view,
     }
 
   gimp_image_flush (gimage);
-
-  gimp_undo_editor_update_buttons (editor);
-}
-
-static void
-gimp_undo_editor_update_buttons (GimpUndoEditor *editor)
-{
-  GimpImage *gimage        = GIMP_IMAGE_EDITOR (editor)->gimage;
-  GimpUndo  *top_undo_item = gimp_undo_stack_peek (gimage->undo_stack);
-  GimpUndo  *top_redo_item = gimp_undo_stack_peek (gimage->redo_stack);
-  gboolean   enabled       = gimp_image_undo_is_enabled (gimage);
-
-  gtk_widget_set_sensitive (editor->undo_button,  enabled && top_undo_item);
-  gtk_widget_set_sensitive (editor->redo_button,  enabled && top_redo_item);
-  gtk_widget_set_sensitive (editor->clear_button, enabled && (top_undo_item ||
-                                                              top_redo_item));
 }
diff --git a/app/widgets/gimpundoeditor.h b/app/widgets/gimpundoeditor.h
index d6cc9cbe92..0e20aa6522 100644
--- a/app/widgets/gimpundoeditor.h
+++ b/app/widgets/gimpundoeditor.h
@@ -56,7 +56,8 @@ struct _GimpUndoEditorClass
 
 GType       gimp_undo_editor_get_type  (void) G_GNUC_CONST;
 
-GtkWidget * gimp_undo_editor_new       (GimpCoreConfig *config);
+GtkWidget * gimp_undo_editor_new       (GimpCoreConfig  *config,
+                                        GimpMenuFactory *menu_factory);
 
 
 #endif /* __GIMP_UNDO_EDITOR_H__ */
diff --git a/app/widgets/gimpvectorstreeview.c b/app/widgets/gimpvectorstreeview.c
index dce296df31..e5524fe98e 100644
--- a/app/widgets/gimpvectorstreeview.c
+++ b/app/widgets/gimpvectorstreeview.c
@@ -2,7 +2,7 @@
  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  *
  * gimpvectorstreeview.c
- * Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
+ * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,14 +23,11 @@
 
 #include <gtk/gtk.h>
 
-#include "libgimpmath/gimpmath.h"
 #include "libgimpwidgets/gimpwidgets.h"
 
 #include "widgets-types.h"
 
 #include "core/gimp.h"
-#include "core/gimpchannel.h"
-#include "core/gimpchannel-select.h"
 #include "core/gimpcontainer.h"
 #include "core/gimpcontext.h"
 #include "core/gimpimage.h"
@@ -49,35 +46,12 @@
 static void   gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass);
 static void   gimp_vectors_tree_view_init       (GimpVectorsTreeView      *view);
 
-static void  gimp_vectors_tree_view_view_iface_init (GimpContainerViewInterface *view_iface);
-
-static gboolean gimp_vectors_tree_view_select_item  (GimpContainerView   *view,
-						     GimpViewable        *item,
-						     gpointer             insert_data);
-static void     gimp_vectors_tree_view_set_image    (GimpItemTreeView    *view,
-                                                     GimpImage           *gimage);
-static void   gimp_vectors_tree_view_toselection_clicked
-                                                    (GtkWidget           *widget,
-						     GimpVectorsTreeView *view);
-static void   gimp_vectors_tree_view_toselection_extended_clicked
-                                                    (GtkWidget           *widget,
-						     guint                state,
-						     GimpVectorsTreeView *view);
-
-static void   gimp_vectors_tree_view_tovectors_clicked
-                                                    (GtkWidget           *widget,
-                                                     GimpVectorsTreeView *view);
-static void   gimp_vectors_tree_view_tovectors_extended_clicked
-                                                    (GtkWidget           *widget,
-                                                     guint                state,
-                                                     GimpVectorsTreeView *view);
-
-static void   gimp_vectors_tree_view_stroke_clicked (GtkWidget           *widget,
-						     GimpVectorsTreeView *view);
+static GObject * gimp_vectors_tree_view_constructor (GType                  type,
+                                                     guint                  n_params,
+                                                     GObjectConstructParam *params);
 
 
-static GimpItemTreeViewClass      *parent_class      = NULL;
-static GimpContainerViewInterface *parent_view_iface = NULL;
+static GimpItemTreeViewClass *parent_class = NULL;
 
 
 GType
@@ -100,19 +74,9 @@ gimp_vectors_tree_view_get_type (void)
         (GInstanceInitFunc) gimp_vectors_tree_view_init,
       };
 
-      static const GInterfaceInfo view_iface_info =
-      {
-        (GInterfaceInitFunc) gimp_vectors_tree_view_view_iface_init,
-        NULL,           /* iface_finalize */
-        NULL            /* iface_data     */
-      };
-
       view_type = g_type_register_static (GIMP_TYPE_ITEM_TREE_VIEW,
                                           "GimpVectorsTreeView",
                                           &view_info, 0);
-
-      g_type_add_interface_static (view_type, GIMP_TYPE_CONTAINER_VIEW,
-                                   &view_iface_info);
     }
 
   return view_type;
@@ -121,11 +85,12 @@ gimp_vectors_tree_view_get_type (void)
 static void
 gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass)
 {
+  GObjectClass          *object_class    = G_OBJECT_CLASS (klass);
   GimpItemTreeViewClass *item_view_class = GIMP_ITEM_TREE_VIEW_CLASS (klass);
 
   parent_class = g_type_class_peek_parent (klass);
 
-  item_view_class->set_image       = gimp_vectors_tree_view_set_image;
+  object_class->constructor        = gimp_vectors_tree_view_constructor;
 
   item_view_class->get_container   = gimp_image_get_vectors;
   item_view_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_vectors;
@@ -156,8 +121,22 @@ gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass)
 static void
 gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
 {
-  GimpEditor *editor = GIMP_EDITOR (view);
-  gchar      *str;
+}
+
+static GObject *
+gimp_vectors_tree_view_constructor (GType                  type,
+                                    guint                  n_params,
+                                    GObjectConstructParam *params)
+{
+  GObject             *object;
+  GimpEditor          *editor;
+  GimpVectorsTreeView *view;
+  gchar               *str;
+
+  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
+
+  editor = GIMP_EDITOR (object);
+  view   = GIMP_VECTORS_TREE_VIEW (object);
 
   /*  Hide basically useless Edit button  */
 
@@ -174,12 +153,18 @@ gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
                          gimp_get_mod_name_control ());
 
   view->toselection_button =
-    gimp_editor_add_button (editor,
-                            GIMP_STOCK_SELECTION_REPLACE, str,
-                            GIMP_HELP_PATH_SELECTION_REPLACE,
-                            G_CALLBACK (gimp_vectors_tree_view_toselection_clicked),
-                            G_CALLBACK (gimp_vectors_tree_view_toselection_extended_clicked),
-                            view);
+    gimp_editor_add_action_button (editor, "vectors",
+                                   "vectors-selection-replace",
+                                   "vectors-selection-intersect",
+                                   GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+                                   "vectors-selection-subtract",
+                                   GDK_CONTROL_MASK,
+                                   "vectors-selection-add",
+                                   GDK_SHIFT_MASK,
+                                   NULL);
+
+  gimp_help_set_help_data (view->toselection_button, str,
+                           GIMP_HELP_PATH_SELECTION_REPLACE);
 
   g_free (str);
 
@@ -188,22 +173,20 @@ gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
                          gimp_get_mod_name_shift ());
 
   view->tovectors_button =
-    gimp_editor_add_button (editor,
-                            GIMP_STOCK_SELECTION_TO_PATH, str,
-                            GIMP_HELP_SELECTION_TO_PATH,
-                            G_CALLBACK (gimp_vectors_tree_view_tovectors_clicked),
-                            G_CALLBACK (gimp_vectors_tree_view_tovectors_extended_clicked),
-                            view);
+    gimp_editor_add_action_button (editor, "vectors",
+                                   "vectors-selection-to-vectors",
+                                   "vectors-selection-to-vectors-advanced",
+                                   GDK_SHIFT_MASK,
+                                   NULL);
+
+  gimp_help_set_help_data (view->tovectors_button, str,
+                           GIMP_HELP_SELECTION_TO_PATH);
 
   g_free (str);
 
   view->stroke_button =
-    gimp_editor_add_button (editor,
-                            GIMP_STOCK_PATH_STROKE, _("Stroke Path"),
-                            GIMP_HELP_PATH_STROKE,
-                            G_CALLBACK (gimp_vectors_tree_view_stroke_clicked),
-                            NULL,
-                            view);
+    gimp_editor_add_action_button (editor, "vectors",
+                                   "vectors-stroke", NULL);
 
   gtk_box_reorder_child (GTK_BOX (editor->button_box),
 			 view->toselection_button, 5);
@@ -219,121 +202,5 @@ gimp_vectors_tree_view_init (GimpVectorsTreeView *view)
 				  GTK_BUTTON (view->stroke_button),
 				  GIMP_TYPE_VECTORS);
 
-  gtk_widget_set_sensitive (view->toselection_button, FALSE);
-  gtk_widget_set_sensitive (view->tovectors_button,   FALSE);
-  gtk_widget_set_sensitive (view->stroke_button,      FALSE);
-}
-
-static void
-gimp_vectors_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
-{
-  parent_view_iface = g_type_interface_peek_parent (view_iface);
-
-  view_iface->select_item = gimp_vectors_tree_view_select_item;
-}
-
-
-/*  GimpContainerView methods  */
-
-static gboolean
-gimp_vectors_tree_view_select_item (GimpContainerView *view,
-				    GimpViewable      *item,
-				    gpointer           insert_data)
-{
-  GimpVectorsTreeView *tree_view = GIMP_VECTORS_TREE_VIEW (view);
-  gboolean             success;
-
-  success = parent_view_iface->select_item (view, item, insert_data);
-
-  gtk_widget_set_sensitive (tree_view->toselection_button, item != NULL);
-  gtk_widget_set_sensitive (tree_view->stroke_button,      item != NULL);
-
-  return success;
-}
-
-static void
-gimp_vectors_tree_view_set_image (GimpItemTreeView *view,
-                                  GimpImage        *gimage)
-{
-  GIMP_ITEM_TREE_VIEW_CLASS (parent_class)->set_image (view, gimage);
-
-  gtk_widget_set_sensitive (GIMP_VECTORS_TREE_VIEW (view)->tovectors_button,
-                            gimage != NULL);
-}
-
-static void
-gimp_vectors_tree_view_toselection_clicked (GtkWidget           *widget,
-					    GimpVectorsTreeView *view)
-{
-  gimp_vectors_tree_view_toselection_extended_clicked (widget, 0, view);
-}
-
-static void
-gimp_vectors_tree_view_toselection_extended_clicked (GtkWidget           *widget,
-						     guint                state,
-						     GimpVectorsTreeView *view)
-{
-  GimpImage *gimage;
-  GimpItem  *item;
-
-  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
-
-  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
-
-  if (item)
-    {
-      GimpChannelOps operation = GIMP_CHANNEL_OP_REPLACE;
-
-      if (state & GDK_SHIFT_MASK)
-	{
-	  if (state & GDK_CONTROL_MASK)
-	    operation = GIMP_CHANNEL_OP_INTERSECT;
-	  else
-	    operation = GIMP_CHANNEL_OP_ADD;
-	}
-      else if (state & GDK_CONTROL_MASK)
-	{
-	  operation = GIMP_CHANNEL_OP_SUBTRACT;
-	}
-
-      gimp_channel_select_vectors (gimp_image_get_mask (gimage),
-                                   _("Path to Selection"),
-                                   GIMP_VECTORS (item),
-                                   operation,
-                                   TRUE,
-                                   FALSE, 0, 0);
-      gimp_image_flush (gimage);
-    }
-}
-
-static void
-gimp_vectors_tree_view_tovectors_clicked (GtkWidget           *widget,
-                                          GimpVectorsTreeView *view)
-{
-  gimp_vectors_tree_view_tovectors_extended_clicked (widget, 0, view);
-}
-
-static void
-gimp_vectors_tree_view_tovectors_extended_clicked (GtkWidget           *widget,
-                                                   guint                state,
-                                                   GimpVectorsTreeView *view)
-{
-  if (view->selection_to_vectors_func)
-    view->selection_to_vectors_func (GIMP_ITEM_TREE_VIEW (view)->gimage,
-                                     (state & GDK_SHIFT_MASK) != 0);
-}
-
-static void
-gimp_vectors_tree_view_stroke_clicked (GtkWidget           *widget,
-                                       GimpVectorsTreeView *view)
-{
-  GimpImage *gimage;
-  GimpItem  *item;
-
-  gimage = GIMP_ITEM_TREE_VIEW (view)->gimage;
-
-  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (gimage);
-
-  if (item && view->stroke_item_func)
-    view->stroke_item_func (item, GTK_WIDGET (view));
+  return object;
 }
diff --git a/app/widgets/gimpvectorstreeview.h b/app/widgets/gimpvectorstreeview.h
index 88aa21bb1d..27bd4bdf4d 100644
--- a/app/widgets/gimpvectorstreeview.h
+++ b/app/widgets/gimpvectorstreeview.h
@@ -38,14 +38,11 @@ typedef struct _GimpVectorsTreeViewClass  GimpVectorsTreeViewClass;
 
 struct _GimpVectorsTreeView
 {
-  GimpItemTreeView            parent_instance;
+  GimpItemTreeView  parent_instance;
 
-  GimpStrokeItemFunc          stroke_item_func;
-  GimpSelectionToVectorsFunc  selection_to_vectors_func;
-
-  GtkWidget                  *toselection_button;
-  GtkWidget                  *tovectors_button;
-  GtkWidget                  *stroke_button;
+  GtkWidget        *toselection_button;
+  GtkWidget        *tovectors_button;
+  GtkWidget        *stroke_button;
 };
 
 struct _GimpVectorsTreeViewClass
diff --git a/app/widgets/widgets-types.h b/app/widgets/widgets-types.h
index 170c1dbb4a..e4778cad62 100644
--- a/app/widgets/widgets-types.h
+++ b/app/widgets/widgets-types.h
@@ -147,22 +147,17 @@ typedef struct _GimpSessionInfoAux      GimpSessionInfoAux;
 
 /*  function types  */
 
-typedef void (* GimpActionGroupSetupFunc)   (GimpActionGroup *group);
-typedef void (* GimpActionGroupUpdateFunc)  (GimpActionGroup *group,
-                                             gpointer         data);
+typedef void (* GimpActionGroupSetupFunc)  (GimpActionGroup *group);
+typedef void (* GimpActionGroupUpdateFunc) (GimpActionGroup *group,
+                                            gpointer         data);
 
-typedef void (* GimpUIManagerSetupFunc)     (GimpUIManager   *manager,
-                                             const gchar     *ui_path);
+typedef void (* GimpUIManagerSetupFunc)    (GimpUIManager   *manager,
+                                            const gchar     *ui_path);
 
-typedef void (* GimpMenuPositionFunc)       (GtkMenu         *menu,
-                                             gint            *x,
-                                             gint            *y,
-                                             gpointer         data);
-
-typedef void (* GimpStrokeItemFunc)         (GimpItem        *item,
-                                             GtkWidget       *parent);
-typedef void (* GimpSelectionToVectorsFunc) (GimpImage       *gimage,
-                                             gboolean         advanced);
+typedef void (* GimpMenuPositionFunc)      (GtkMenu         *menu,
+                                            gint            *x,
+                                            gint            *y,
+                                            gpointer         data);
 
 
 #endif /* __WIDGETS_TYPES_H__ */
diff --git a/menus/Makefile.am b/menus/Makefile.am
index bfc4ddb3e6..e144b28182 100644
--- a/menus/Makefile.am
+++ b/menus/Makefile.am
@@ -28,6 +28,7 @@ menudata_DATA = \
 	palettes-menu.xml		\
 	patterns-menu.xml		\
 	qmask-menu.xml			\
+	selection-editor-menu.xml	\
 	templates-menu.xml		\
 	tool-options-menu.xml		\
 	tools-menu.xml			\
diff --git a/menus/image-menu.xml.in b/menus/image-menu.xml.in
index c2ee6a88eb..26b29c278c 100644
--- a/menus/image-menu.xml.in
+++ b/menus/image-menu.xml.in
@@ -65,7 +65,7 @@
         <menuitem action="edit-fill-pattern" />
       </placeholder>
       <placeholder name="Stroke">
-        <menuitem action="edit-stroke" />
+        <menuitem action="select-stroke" />
         <menuitem action="vectors-stroke" />
       </placeholder>
       <separator />
diff --git a/menus/selection-editor-menu.xml b/menus/selection-editor-menu.xml
new file mode 100644
index 0000000000..a39079e33b
--- /dev/null
+++ b/menus/selection-editor-menu.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE ui SYSTEM "gtkuimanager.dtd">
+
+<ui>
+  <popup action="selection-editor-popup">
+    <menuitem action="select-all" />
+    <menuitem action="select-none" />
+    <menuitem action="select-invert" />
+    <menuitem action="select-from-vectors" />
+    <menuitem action="select-float" />
+    <separator />
+    <placeholder name="Outline">
+      <menuitem action="select-feather" />
+      <menuitem action="select-sharpen" />
+      <menuitem action="select-shrink" />
+      <menuitem action="select-grow" />
+      <menuitem action="select-border" />
+    </placeholder>
+    <separator />
+    <menuitem action="select-save" />
+    <menuitem action="select-to-vectors" />
+    <menuitem action="select-stroke" />
+  </popup>
+</ui>
diff --git a/menus/selection-menu.xml b/menus/selection-menu.xml
new file mode 100644
index 0000000000..a39079e33b
--- /dev/null
+++ b/menus/selection-menu.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE ui SYSTEM "gtkuimanager.dtd">
+
+<ui>
+  <popup action="selection-editor-popup">
+    <menuitem action="select-all" />
+    <menuitem action="select-none" />
+    <menuitem action="select-invert" />
+    <menuitem action="select-from-vectors" />
+    <menuitem action="select-float" />
+    <separator />
+    <placeholder name="Outline">
+      <menuitem action="select-feather" />
+      <menuitem action="select-sharpen" />
+      <menuitem action="select-shrink" />
+      <menuitem action="select-grow" />
+      <menuitem action="select-border" />
+    </placeholder>
+    <separator />
+    <menuitem action="select-save" />
+    <menuitem action="select-to-vectors" />
+    <menuitem action="select-stroke" />
+  </popup>
+</ui>