Merge lp:~aauzi/midori/fix-1006629 into lp:midori

[André Auzi]

Coming after lp:~aauzi/midori/fix-894143, this proposes bookmark creation by Dnd from Location bar into the bookmarkbar and ordering of the bookmarkbar with Dnd.

Preliminary code for Dnd creation from tabs is deactivated. It needs rework to adapt to recent tabby evolutions.

[lp:~aauzi/midori/fix-1006629]

6212. By André Auzi on 2014-01-26

merge lp:midori

Unmerged revisions

6212. By André Auzi on 2014-01-26

merge lp:midori

6211. By André Auzi on 2014-01-26

Merge lp:~aauzi/midori/fix-894143 with pos_bar order

6210. By André Auzi on 2014-01-26

Fix bookmarkbar item position updates

6209. By André Auzi on 2014-01-25

Put traces in midori_debug ("bookmarks")

6208. By André Auzi on 2014-01-25

merge lp:midori, remove tab drag-n-drop due to tabby evolutions

6207. By André Auzi on 2013-09-28

merge lp:midori

6206. By André Auzi on 2013-09-28

connect menu button press event

6205. By André Auzi on 2013-06-14

merge lp:midori

6204. By André Auzi on 2013-06-14

fix hilight item width

6203. By André Auzi on 2013-06-13

merge lp:midori

=== modified file 'katze/katze-array.c'
--- katze/katze-array.c	2013-11-04 20:57:37 +0000
+++ katze/katze-array.c	2014-01-26 19:44:25 +0000
@@ -33,6 +33,15 @@
     GList* items;
 };
 
+enum
+{
+  PROP_0,
+
+  PROP_TYPE,
+
+  N_PROPERTIES
+};
+
 enum {
     ADD_ITEM,
     REMOVE_ITEM,
@@ -55,6 +64,17 @@
 {
     g_object_set_data (G_OBJECT (array), "last-update",
                        GINT_TO_POINTER (time (NULL)));
+/* #define DEBUG_UPDATE */
+#ifdef DEBUG_UPDATE
+    if (KATZE_IS_ITEM (array))
+    {
+        const gchar *name = katze_item_get_name (KATZE_ITEM (array));
+        if (name && *name)
+        {
+            g_print ("_katze_array_update: %s\n", name);
+        }
+    }
+#endif
 }
 
 static void
@@ -105,6 +125,27 @@
 }
 
 static void
+_katze_array_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  KatzeArray *array = KATZE_ARRAY (object);
+
+  switch (property_id)
+    {
+    case PROP_TYPE:
+      array->priv->type = g_value_get_gtype (value);
+      break;
+
+    default:
+      /* We don't have any other property... */
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
 katze_array_class_init (KatzeArrayClass* class)
 {
     GObjectClass* gobject_class;
@@ -187,6 +228,7 @@
 
     gobject_class = G_OBJECT_CLASS (class);
     gobject_class->finalize = katze_array_finalize;
+    gobject_class->set_property = _katze_array_set_property;
 
     class->add_item = _katze_array_add_item;
     class->remove_item = _katze_array_remove_item;
@@ -194,6 +236,16 @@
     class->clear = _katze_array_clear;
     class->update = _katze_array_update;
 
+
+    g_object_class_install_property (gobject_class,
+                                     PROP_TYPE,
+                                     g_param_spec_gtype (
+                                     "type",
+                                     "Type",
+                                     "The array item type",
+                                     G_TYPE_NONE,
+                                     G_PARAM_WRITABLE|G_PARAM_CONSTRUCT_ONLY));
+
     g_type_class_add_private (class, sizeof (KatzeArrayPrivate));
 }
 
@@ -238,8 +290,7 @@
 
     g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
 
-    array = g_object_new (KATZE_TYPE_ARRAY, NULL);
-    array->priv->type = type;
+    array = g_object_new (KATZE_TYPE_ARRAY, "type", type, NULL);
 
     return array;
 }
 
=== modified file 'katze/katze-arrayaction.c'
--- katze/katze-arrayaction.c	2012-12-16 18:40:00 +0000
+++ katze/katze-arrayaction.c	2014-01-26 19:44:25 +0000
@@ -29,6 +29,10 @@
 
     KatzeArray* array;
     gboolean reversed;
+
+    GtkTargetList*  dnd_targets;
+    GdkEventButton *press_event;
+    GdkEventButton stock_press_event;
 };
 
 struct _KatzeArrayActionClass
@@ -43,7 +47,8 @@
     PROP_0,
 
     PROP_ARRAY,
-    PROP_REVERSED
+    PROP_REVERSED,
+    PROP_DND_TARGETS
 };
 
 enum
@@ -215,6 +220,20 @@
         "Whether the array should be walked backwards when building menus",
                                      FALSE,
                                      G_PARAM_READWRITE));
+    /**
+     * KatzeArrayAction:dnd-targets:
+     *
+     * GtkTargetList* the array supports.
+     *
+     * Since: 0.5.2
+     **/
+    g_object_class_install_property (gobject_class,
+                                     PROP_DND_TARGETS,
+                                     g_param_spec_pointer (
+                                     "dnd-targets",
+                                     "DNDTargets",
+        "GtkTargetList* the array supports",
+                                     G_PARAM_READABLE|G_PARAM_WRITABLE));
 }
 
 static void
@@ -222,6 +241,8 @@
 {
     array_action->array = NULL;
     array_action->reversed = FALSE;
+    array_action->dnd_targets = NULL;
+    array_action->press_event = NULL;
 }
 
 static void
@@ -229,6 +250,9 @@
 {
     KatzeArrayAction* array_action = KATZE_ARRAY_ACTION (object);
 
+    if (array_action->dnd_targets)
+        gtk_target_list_unref (array_action->dnd_targets);
+
     katze_object_assign (array_action->array, NULL);
 
     G_OBJECT_CLASS (katze_array_action_parent_class)->finalize (object);
@@ -250,6 +274,9 @@
     case PROP_REVERSED:
         array_action->reversed = g_value_get_boolean (value);
         break;
+    case PROP_DND_TARGETS:
+        array_action->dnd_targets = (GtkTargetList*)g_value_get_pointer (value);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -272,6 +299,9 @@
     case PROP_REVERSED:
         g_value_set_boolean (value, array_action->reversed);
         break;
+    case PROP_DND_TARGETS:
+        g_value_set_pointer (value, array_action->dnd_targets);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -310,8 +340,29 @@
                                          GdkEventButton*   event,
                                          KatzeArrayAction* array_action)
 {
+    array_action->stock_press_event = *event;
+    array_action->press_event = &array_action->stock_press_event;
+
+    return FALSE;
+}
+
+static gboolean
+katze_array_action_menu_button_release_cb (GtkWidget*        proxy,
+                                           GdkEventButton*   event,
+                                           KatzeArrayAction* array_action)
+{
     KatzeItem* item = g_object_get_data (G_OBJECT (proxy), "KatzeItem");
 
+    if (array_action->press_event)
+    {
+        gint x = array_action->press_event->x;
+        gint y = array_action->press_event->y;
+        array_action->press_event = NULL;
+
+        if (x != event->x || y != event->y)
+            return TRUE;
+    }
+
     katze_array_action_activate_item (array_action, item, event->button);
 
     /* we need to block the 'activate' handler which would be called
@@ -323,6 +374,120 @@
 }
 
 static void
+katze_array_action_item_drag_source_drag_data_get (
+    KatzeItem *item,
+    GdkDragContext *drag_context,
+    GtkSelectionData *data,
+    guint info,
+    guint time,
+    KatzeArrayAction* action)
+{
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    switch (gdk_drag_context_get_selected_action (drag_context))
+    {
+    default:
+        break;
+    case GDK_ACTION_MOVE:
+    case GDK_ACTION_COPY:
+        if (selection_data_from_katze_item (data, item))
+            break;
+    case GDK_ACTION_LINK:
+        if (KATZE_ITEM_IS_BOOKMARK (item))
+        {
+            const gchar* uri = katze_item_get_uri (item);
+            if (uri && *uri)
+            {
+                gchar* src_uris[2];
+                gchar** uris;
+
+                src_uris[0] = (gchar*)uri;
+                src_uris[1] = NULL;
+
+                uris = g_strdupv (src_uris);
+
+                gtk_selection_data_set_uris (data, uris);
+                gtk_selection_data_set_text (data, uri, -1);
+
+                g_strfreev (uris);
+            }
+        }
+        break;
+    }
+}
+
+static void
+katze_array_action_menu_item_drag_source_drag_data_get_cb (
+    GtkWidget *widget,
+    GdkDragContext *drag_context,
+    GtkSelectionData *data,
+    guint info,
+    guint time,
+    KatzeArrayAction* action)
+{
+    KatzeItem* item = (KatzeItem*)g_object_get_data (G_OBJECT (widget), "KatzeItem");
+
+    katze_array_action_item_drag_source_drag_data_get (item, drag_context, data, info, time, action);
+}
+
+static void
+katze_array_action_tool_item_child_drag_source_drag_data_get_cb (
+    GtkWidget *widget,
+    GdkDragContext *drag_context,
+    GtkSelectionData *data,
+    guint info,
+    guint time,
+    KatzeArrayAction *action)
+{
+    GtkWidget* proxy = gtk_widget_get_parent (widget);
+    KatzeItem* item = (KatzeItem*)g_object_get_data (G_OBJECT (proxy), "KatzeItem");
+    GtkToolbar* toolbar = GTK_TOOLBAR (gtk_widget_get_parent (proxy));
+    gint pos;
+
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    pos = gtk_toolbar_get_item_index (toolbar, GTK_TOOL_ITEM (proxy));
+    if (pos != katze_item_get_meta_integer (item, "pos_bar"))
+        katze_item_set_meta_integer (item, "pos_bar", pos);
+
+    katze_array_action_item_drag_source_drag_data_get (item, drag_context, data, info, time, action);
+}
+
+extern void midori_bookmarkbar_position_items (GtkWidget *widget);
+
+
+static void
+katze_array_action_tool_item_child_drag_source_drag_data_delete_cb (
+    GtkWidget *widget,
+    GdkDragContext *drag_context,
+    KatzeArrayAction* action)
+{
+    GtkWidget* proxy = gtk_widget_get_parent (widget);
+    KatzeItem* item = (KatzeItem*)g_object_get_data (G_OBJECT (proxy), "KatzeItem");
+    GtkToolbar* toolbar = GTK_TOOLBAR (gtk_widget_get_parent (proxy));
+
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    gtk_container_remove (GTK_CONTAINER (toolbar), proxy);
+
+    midori_bookmarkbar_position_items (GTK_WIDGET (toolbar));
+}
+
+static void
+katze_array_action_menu_item_drag_source_drag_data_delete_cb (
+    GtkWidget *proxy,
+    GdkDragContext *drag_context,
+    KatzeArrayAction* action)
+{
+    KatzeItem* item = (KatzeItem*)g_object_get_data (G_OBJECT (proxy), "KatzeItem");
+    GtkMenuShell* menu = GTK_MENU_SHELL (gtk_widget_get_parent (proxy));
+
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    gtk_container_remove (GTK_CONTAINER (menu), proxy);
+}
+
+static void
 katze_array_action_menu_item_select_cb (GtkWidget*        proxy,
                                         KatzeArrayAction* array_action);
 
@@ -407,6 +572,24 @@
                 G_CALLBACK (katze_array_action_menu_item_select_cb), array_action);
             g_signal_connect (menuitem, "activate",
                 G_CALLBACK (katze_array_action_menu_item_select_cb), array_action);
+#if 0
+            /* TODO: insert menu DND dest code here */
+            if (array_action->dnd_targets)
+            {
+                gtk_drag_dest_set (submenu, GTK_DEST_DEFAULT_ALL, NULL, 0,
+                    GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
+                gtk_drag_dest_set_target_list (submenu, array_action->dnd_targets);
+                g_signal_connect (submenu, "drag-motion",
+                    G_CALLBACK (katze_array_action_menu_drag_dest_drag_motion_cb), 
+                    array_action);
+                g_signal_connect (submenu, "drag-leave",
+                    G_CALLBACK (katze_array_action_menu_drag_dest_drag_leave_cb), 
+                    array_action);
+                g_signal_connect (submenu, "drag-data-received",
+                    G_CALLBACK (katze_array_action_menu_drag_dest_drag_data_received_cb), 
+                    array_action);
+            }
+#endif
         }
         else
         {
@@ -416,6 +599,23 @@
         }
         g_signal_connect (menuitem, "button-press-event",
             G_CALLBACK (katze_array_action_menu_button_press_cb), array_action);
+        g_signal_connect (menuitem, "button-release-event",
+            G_CALLBACK (katze_array_action_menu_button_release_cb), array_action);
+
+
+        if (array_action->dnd_targets)
+        {
+            gtk_drag_source_set (menuitem, GDK_BUTTON1_MASK, NULL, 0,
+                GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
+            gtk_drag_source_set_target_list (menuitem, array_action->dnd_targets);
+            g_signal_connect (menuitem, "drag-data-get",
+                G_CALLBACK (katze_array_action_menu_item_drag_source_drag_data_get_cb), 
+                array_action);
+            g_signal_connect (menuitem, "drag-data-delete",
+                G_CALLBACK (katze_array_action_menu_item_drag_source_drag_data_delete_cb), 
+                array_action);
+        }
+
         gtk_widget_show (menuitem);
     }
 }
@@ -622,15 +822,49 @@
         gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
         g_signal_connect (menuitem, "select",
             G_CALLBACK (katze_array_action_menu_item_select_cb), array_action);
+#if 0
+        /* TODO: insert menu DND menu code here */
+        if (array_action->dnd_targets)
+        {
+            gtk_drag_dest_set (submenu, GTK_DEST_DEFAULT_ALL, NULL, 0,
+                GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
+            gtk_drag_dest_set_target_list (submenu, array_action->dnd_targets);
+            g_signal_connect (submenu, "drag-motion",
+                G_CALLBACK (katze_array_action_menu_drag_dest_drag_motion_cb), 
+                array_action);
+            g_signal_connect (submenu, "drag-leave",
+                G_CALLBACK (katze_array_action_menu_drag_dest_drag_leave_cb), 
+                array_action);
+            g_signal_connect (submenu, "drag-data-received",
+                G_CALLBACK (katze_array_action_menu_drag_dest_drag_data_received_cb), 
+                array_action);
+	    }
+#endif
     }
     else
     {
         g_signal_connect (menuitem, "button-press-event",
             G_CALLBACK (katze_array_action_menu_button_press_cb), array_action);
+        g_signal_connect (menuitem, "button-release-event",
+            G_CALLBACK (katze_array_action_menu_button_release_cb), array_action);
         /* we need the 'activate' signal as well for keyboard events */
         g_signal_connect (menuitem, "activate",
             G_CALLBACK (katze_array_action_menu_activate_cb), array_action);
     }
+
+    if (array_action->dnd_targets)
+    {
+        gtk_drag_source_set (menuitem, GDK_BUTTON1_MASK, NULL, 0,
+            GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
+        gtk_drag_source_set_target_list (menuitem, array_action->dnd_targets);
+        g_signal_connect (menuitem, "drag-data-get",
+            G_CALLBACK (katze_array_action_menu_item_drag_source_drag_data_get_cb), 
+            array_action);
+        g_signal_connect (menuitem, "drag-data-delete",
+            G_CALLBACK (katze_array_action_menu_item_drag_source_drag_data_delete_cb), 
+            array_action);
+    }
+
     gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (proxy),
         "katze-tool-item-menu", menuitem);
     return TRUE;
@@ -706,9 +940,33 @@
     else
         gtk_tool_item_set_tooltip_text (toolitem, uri);
 
-    g_object_set_data (G_OBJECT (toolitem), "KatzeArray", item);
+    g_object_set_data (G_OBJECT (toolitem), "KatzeItem", item);
     g_signal_connect (toolitem, "clicked",
         G_CALLBACK (katze_array_action_proxy_clicked_cb), array_action);
+    if (KATZE_IS_ITEM (item))
+    {
+        GtkWidget* child = gtk_bin_get_child (GTK_BIN (toolitem));
+        
+        if (KATZE_ITEM_IS_FOLDER (item) && array_action->dnd_targets)
+        {
+#if 0
+            /* TODO: add toggle button DND dest code here */
+#endif
+        }
+
+        if (array_action->dnd_targets)
+        {
+            gtk_drag_source_set (child, GDK_BUTTON1_MASK, NULL, 0,
+                GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
+            gtk_drag_source_set_target_list (child, array_action->dnd_targets);
+            g_signal_connect (child, "drag-data-get",
+                G_CALLBACK (katze_array_action_tool_item_child_drag_source_drag_data_get_cb), 
+                array_action);
+            g_signal_connect (child, "drag-data-delete",
+                G_CALLBACK (katze_array_action_tool_item_child_drag_source_drag_data_delete_cb), 
+                array_action);
+        }
+    }
 
     g_object_set_data (G_OBJECT (toolitem), "KatzeArrayAction", array_action);
     g_signal_connect (item, "notify",
@@ -767,12 +1025,14 @@
                               KatzeArray*       array)
 {
     GSList* proxies;
+    KatzeArray *old_array = NULL;
 
     g_return_if_fail (KATZE_IS_ARRAY_ACTION (array_action));
     g_return_if_fail (!array || katze_array_is_a (array, KATZE_TYPE_ITEM));
 
     /* FIXME: Disconnect old array */
 
+    old_array = array_action->array;
     if (array)
         g_object_ref (array);
     katze_object_assign (array_action->array, array);
@@ -793,7 +1053,15 @@
 
     do
     {
+        KatzeArray* item = g_object_get_data (G_OBJECT (proxies->data), "KatzeItem");
+
+        if (item && (item == old_array))
+            g_object_set_data (G_OBJECT (proxies->data), "KatzeItem", array);
+
         gtk_widget_set_sensitive (proxies->data, array != NULL);
     }
     while ((proxies = g_slist_next (proxies)));
+
+    if (array)
+        katze_array_update (KATZE_ARRAY (array));
 }
 
=== modified file 'katze/katze-utils.c'
--- katze/katze-utils.c	2013-11-05 21:51:18 +0000
+++ katze/katze-utils.c	2014-01-26 19:44:25 +0000
@@ -29,6 +29,13 @@
     #include <unistd.h>
 #endif
 
+typedef struct _KatzeArrayData KatzeArrayData; 
+
+struct _KatzeArrayData
+{
+    KatzeItem* items[1];
+};
+
 #define I_ g_intern_static_string
 
 static void
@@ -1002,12 +1009,99 @@
 
     g_return_val_if_fail (GTK_IS_TREE_VIEW (treeview), FALSE);
 
-    if ((selection = gtk_tree_view_get_selection (treeview)))
-        if (gtk_tree_selection_get_selected (selection, model, iter))
-            return TRUE;
+    selection = gtk_tree_view_get_selection(treeview);
+    
+    switch (gtk_tree_selection_get_mode (selection))
+    {
+	default:
+	    break;
+
+	case GTK_SELECTION_SINGLE:
+	case GTK_SELECTION_BROWSE:
+	    if (gtk_tree_selection_get_selected (selection, model, iter))
+		return TRUE;
+	    break;
+
+	case GTK_SELECTION_MULTIPLE:
+	    if (gtk_tree_selection_count_selected_rows (selection) == 1)
+	    {
+		GtkTreeModel *stock_model;
+		GList *list = gtk_tree_selection_get_selected_rows (selection, &stock_model);
+		
+		if (model)
+		    *model = stock_model;
+		
+		if (list)
+		{
+		    GtkTreePath *path = (GtkTreePath *)g_list_nth_data (list, 0);
+		    
+		    if (path && (!iter || gtk_tree_model_get_iter (stock_model, iter, path)))
+		    {
+			g_list_free_full(list, (GDestroyNotify) gtk_tree_path_free);
+			return TRUE;
+		    }
+		    
+		    g_list_free_full(list, (GDestroyNotify) gtk_tree_path_free);
+		}
+	    }
+    }
+
     return FALSE;
 }
 
+/**
+ * katze_tree_view_get_selected_rows:
+ * @treeview: a #GtkTreeView
+ * @model: a pointer to store the #GtkTreeModel, or %NULL
+ * @rows: a pointer to store the #GList of #GtkTreePath, or %NULL
+ *
+ * Determines whether there is a selection in @treeview
+ * and sets the @rows to the current selection.
+ *
+ * If there is a selection and @model is not %NULL, it is
+ * set to the model. If @model is %NULL, the @rows will be
+ * set to %NULL.
+ *
+ * Either @model or @rows or both can be %NULL in which case
+ * no value will be assigned in any case.
+ *
+ * When @rows is not %NULL it must be freed using:
+ * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
+ *
+ * Return value: the count of selected rows
+ *
+ * Since: 0.4.7.aau.1
+ **/
+
+gint
+katze_tree_view_get_selected_rows (GtkTreeView*   treeview,
+                                   GtkTreeModel** model,
+                                   GList**        rows)
+{
+    gint count;
+    GtkTreeSelection* selection;
+    
+    if (model)
+        *model = NULL;
+    if (rows)
+        *rows = NULL;
+    
+    g_return_val_if_fail (GTK_IS_TREE_VIEW (treeview), 0);
+    
+    selection = gtk_tree_view_get_selection(treeview);
+    
+    count = gtk_tree_selection_count_selected_rows (selection);
+    if (count > 0)
+    {
+        if (model && rows)
+	{
+	    *rows = gtk_tree_selection_get_selected_rows (selection, model);
+	}
+    }
+    
+    return count;
+}
+
 void
 katze_bookmark_populate_tree_view (KatzeArray*   array,
                                    GtkTreeStore* model,
@@ -1377,3 +1471,62 @@
     gtk_widget_set_size_request (GTK_WIDGET (window), 700, 100);
 }
 
+gboolean
+selection_data_from_katze_item (GtkSelectionData* selection_data, KatzeItem* item)
+{
+    GdkAtom katze_array_atom = gdk_atom_intern_static_string ("KATZE_ARRAY");
+    KatzeArrayData  *kad;
+
+    g_return_val_if_fail (selection_data != NULL, FALSE);
+    g_return_val_if_fail (KATZE_IS_ITEM (item), FALSE);
+
+    if (gtk_selection_data_get_target (selection_data) != katze_array_atom)
+        return FALSE;
+
+    kad = g_malloc (sizeof (KatzeArrayData));
+
+    kad->items[0] = item;
+
+    gtk_selection_data_set (selection_data,
+        katze_array_atom,
+        8, /* bytes */
+        (void*)kad,
+        sizeof (KatzeArrayData));
+
+    g_free (kad);
+    return TRUE;
+}
+
+KatzeArray*
+katze_array_from_selection_data (GtkSelectionData* selection_data)
+{
+    GdkAtom katze_array_atom = gdk_atom_intern_static_string ("KATZE_ARRAY");
+    KatzeArrayData  *kad;
+    KatzeArray  *array;
+    gint size;
+    gint count;
+    gint i;
+
+    g_return_val_if_fail (selection_data != NULL, FALSE);
+
+    if (gtk_selection_data_get_target (selection_data) != katze_array_atom)
+        return NULL;
+
+    if (gtk_selection_data_get_format (selection_data) != 8)
+        return NULL;
+    
+    size = gtk_selection_data_get_length (selection_data);
+    if (size <= 0)
+        return NULL;
+    
+    kad = (void*) gtk_selection_data_get_data (selection_data);
+
+    count = (size - G_STRUCT_OFFSET (KatzeArrayData, items))/sizeof(KatzeItem*);
+
+    array = katze_array_new (KATZE_TYPE_ARRAY);
+
+    for ( i = 0; i < count; i++ )
+        katze_array_add_item (array, kad->items[i]);
+
+    return array;
+}
 
=== modified file 'katze/katze-utils.h'
--- katze/katze-utils.h	2013-04-16 22:10:56 +0000
+++ katze/katze-utils.h	2014-01-26 19:44:25 +0000
@@ -88,6 +88,11 @@
                                       GtkTreeModel** model,
                                       GtkTreeIter*   iter);
 
+gint
+katze_tree_view_get_selected_rows    (GtkTreeView*   treeview,
+                                      GtkTreeModel** model,
+                                      GList**        rows);
+
 void
 katze_bookmark_populate_tree_view    (KatzeArray* array,
                                       GtkTreeStore* model,
@@ -138,6 +143,12 @@
 void
 katze_window_set_sensible_default_size (GtkWindow*    window);
 
+gboolean
+selection_data_from_katze_item (GtkSelectionData* selection_data, KatzeItem* item);
+
+KatzeArray*
+katze_array_from_selection_data (GtkSelectionData* selection_data);
+
 G_END_DECLS
 
 #endif /* __KATZE_UTILS_H__ */
 
=== modified file 'midori/midori-array.c'
--- midori/midori-array.c	2013-08-05 19:52:52 +0000
+++ midori/midori-array.c	2014-01-26 19:44:25 +0000
@@ -1031,9 +1031,16 @@
           || g_str_equal (name, "last_visit") || g_str_equal (name, "visit_count")
           || g_str_equal (name, "pos_panel") || g_str_equal (name, "pos_bar"))
     {
+#if 0
         gint value;
         value = sqlite3_column_int64 (stmt, column);
         katze_item_set_meta_integer (item, name, value);
+#else
+        /* use text to properly handle NULL values */
+        const unsigned char* text;
+        text = sqlite3_column_text (stmt, column);
+        katze_item_set_meta_string (item, name, (gchar*)text);
+#endif
     }
     else if (g_str_equal (name, "desc"))
     {
 
=== modified file 'midori/midori-bookmarks-db.c'
--- midori/midori-bookmarks-db.c	2014-01-24 23:04:05 +0000
+++ midori/midori-bookmarks-db.c	2014-01-26 19:44:25 +0000
@@ -181,14 +181,29 @@
 midori_bookmarks_db_get_item_parent (MidoriBookmarksDb* bookmarks,
                                      gpointer    item)
 {
+    gint64 parentid = katze_item_get_meta_integer (KATZE_ITEM (item), "parentid");
+    KatzeItem *search = katze_item_new ();
     KatzeArray* parent;
-    gint64 parentid;
-
-    parentid = katze_item_get_meta_integer (KATZE_ITEM (item), "parentid");
-
-    if (parentid == 0)
-    {
+
+    if (!parentid)
+    {
+        parentid = katze_item_get_meta_integer (KATZE_ITEM (bookmarks), "id");
+        katze_item_set_meta_integer (KATZE_ITEM (item), "parentid", parentid);
+    }
+
+    katze_item_set_meta_integer(search, "id", parentid);
+
+    parent = KATZE_ARRAY (g_hash_table_lookup (bookmarks->all_items, search));
+
+    g_object_unref (search);
+
+    if (!parent)
+    {
+        g_warning ("item parent not found\n");
+
         parent = KATZE_ARRAY (bookmarks);
+        katze_item_set_meta_integer (KATZE_ITEM (item), "parentid",
+            katze_item_get_meta_integer (KATZE_ITEM (bookmarks), "id"));
     }
     else
     {
@@ -267,7 +282,10 @@
 
     g_return_if_fail (parent);
 
-    katze_array_update (parent);
+    if (IS_MIDORI_BOOKMARKS_DB (parent))
+        KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->update (parent);
+    else
+        katze_array_update (parent);
 }
 
 /**
@@ -479,7 +497,7 @@
     else if (old_parent && katze_item_get_meta_integer (old_parent, "id") > 0)
         new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer (old_parent, "id"));
     else
-        new_parentid = g_strdup_printf ("NULL");
+        new_parentid = g_strdup ("NULL");
 
     sqlcmd = sqlite3_mprintf (
         "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
@@ -557,7 +575,8 @@
 
     sqlcmd = sqlite3_mprintf (
         "UPDATE bookmarks SET "
-        "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
+        "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d, "
+        "pos_bar=%d, pos_panel=%d "
         "WHERE id = %q ;",
         parentid,
         katze_item_get_name (item),
@@ -565,6 +584,8 @@
         katze_str_non_null (katze_item_get_meta_string (item, "desc")),
         katze_item_get_meta_boolean (item, "toolbar"),
         katze_item_get_meta_boolean (item, "app"),
+        (gint)katze_item_get_meta_integer (item, "pos_bar"),
+        (gint)katze_item_get_meta_integer (item, "pos_panel"),
         id);
 
     updated = TRUE;
@@ -579,6 +600,14 @@
     g_free (parentid);
     g_free (id);
 
+#ifdef DEBUG_DB_UPDATE
+    g_print ("update:%s - parentid: %s, pos_bar:%d, pos_panel:%d\n",
+        katze_item_get_name (item),
+        parentid,
+        (gint)katze_item_get_meta_integer (item, "pos_bar"),
+        (gint)katze_item_get_meta_integer (item, "pos_panel"));
+#endif
+
     return updated;
 }
 
@@ -710,10 +739,10 @@
     g_return_val_if_fail (errmsg != NULL, NULL);
 
     database = midori_bookmarks_database_new (&error);
-    
+
     if (error != NULL)
     {
-	*errmsg = g_strdup (error->message);
+        *errmsg = g_strdup (error->message);
         g_error_free (error);
         return NULL;
     }
@@ -724,7 +753,10 @@
     if (midori_debug ("bookmarks"))
         sqlite3_trace (db, midori_bookmarks_db_dbtracer, NULL);
 
-    bookmarks = MIDORI_BOOKMARKS_DB (g_object_new (TYPE_MIDORI_BOOKMARKS_DB, NULL));
+    bookmarks = MIDORI_BOOKMARKS_DB (g_object_new (TYPE_MIDORI_BOOKMARKS_DB,
+            "type", KATZE_TYPE_ITEM,
+            NULL));
+
     bookmarks->db = db;
 
     g_object_set_data (G_OBJECT (bookmarks), "db", db);
@@ -776,6 +808,7 @@
         katze_item_set_meta_integer (item, "parentid", parentid);
         midori_bookmarks_db_add_item (bookmarks, item);
     }
+
     g_list_free (list);
 }
 
@@ -859,7 +892,7 @@
  * @array: the main bookmark array
  * @sqlcmd: the sqlcmd to execute
  *
- * Internal function that process the requested @sqlcmd.
+ * Internal function that processes the requested @sqlcmd.
  *
  * Return value: a #KatzeArray on success, %NULL otherwise
  **/
@@ -885,6 +918,10 @@
  * @fields: comma separated list of fields
  * @condition: condition, like "folder = '%q'"
  * @value: a value to be inserted if @condition contains %q
+ * @order: a value to be inserted in "ORDER BY"
+ *   default order is :
+ *      (uri='') ASC, title DESC
+ *   given @order, when not %NULL, replaces the term: (uri='') ASC 
  * @recursive: if %TRUE include children
  *
  * Stores the result in a #KatzeArray.
@@ -898,6 +935,7 @@
                                   const gchar* fields,
                                   const gchar* condition,
                                   const gchar* value,
+                                  const gchar* order,
                                   gboolean     recursive)
 {
     gchar* sqlcmd;
@@ -911,7 +949,8 @@
     g_return_val_if_fail (condition, NULL);
 
     sqlcmd = g_strdup_printf ("SELECT %s FROM bookmarks WHERE %s "
-                              "ORDER BY (uri='') ASC, title DESC", fields, condition);
+                              "ORDER BY %s, title DESC", fields, condition, order ? order : "(uri='') ASC");
+
     if (strstr (condition, "%q"))
     {
         sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
@@ -932,7 +971,7 @@
             gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
                                                katze_item_get_meta_integer (item, "id"));
             KatzeArray* subarray = midori_bookmarks_db_query_recursive (bookmarks,
-                                                                        fields, "parentid=%q", parentid, TRUE);
+                                                                        fields, "parentid=%q", parentid, order, TRUE);
             KatzeItem* subitem;
             GList* sublist;
 
@@ -1097,3 +1136,55 @@
                                                       value, id,
                                                       recursive);
 }
+
+/**
+ * midori_bookmarks_db_populate_folder:
+ **/
+
+void
+midori_bookmarks_db_populate_folder (MidoriBookmarksDb*  bookmarks,
+                                     KatzeArray *folder)
+{
+    const gchar* id = katze_item_get_meta_string (KATZE_ITEM (folder), "id");
+    const gchar *condition;
+    KatzeArray* array;
+    KatzeItem* item;
+    GList* list;
+
+    if (id == NULL)
+    {
+        condition = "parentid is NULL";
+    }
+    else
+    {
+        condition = "parentid = %q";
+    }
+
+    array = midori_bookmarks_db_query_recursive (bookmarks,
+        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, "(uri='') ASC, pos_panel ASC", FALSE);
+
+    if (IS_MIDORI_BOOKMARKS_DB (folder))
+    {
+        KATZE_ARRAY_FOREACH_ITEM_L (item, folder, list)
+        {
+            KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->remove_item (folder, item);
+        }
+
+        KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+        {
+            KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->add_item (folder, item);
+        }
+    }
+    else
+    {
+        katze_array_clear(folder);
+
+        KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+        {
+            katze_array_add_item (folder, item);
+        }
+    }
+
+    g_object_unref (array);
+}
+
 
=== modified file 'midori/midori-bookmarks-db.h'
--- midori/midori-bookmarks-db.h	2013-09-17 19:34:23 +0000
+++ midori/midori-bookmarks-db.h	2014-01-26 19:44:25 +0000
@@ -62,19 +62,21 @@
                                      const gchar* fields,
                                      const gchar* condition,
                                      const gchar* value,
+                                     const gchar* order,
                                      gboolean     recursive);
 
 gint64
 midori_bookmarks_db_count_recursive (MidoriBookmarksDb*  bookmarks,
-				     const gchar*        condition,
+			                         const gchar*        condition,
                                      const gchar*        value,
-				     KatzeItem*          folder,
-				     gboolean            recursive);
-
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid);
+			                         KatzeItem*          folder,
+    		                         gboolean            recursive);
+
+void
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* array);
+
+void
+midori_bookmarks_db_populate_folder (MidoriBookmarksDb*  bookmarks,
+                                     KatzeArray *folder);
 
 #endif /* !__MIDORI_BOOKMARKS_DB_H__ */
-
 
=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2014-01-06 23:05:10 +0000
+++ midori/midori-browser.c	2014-01-26 19:44:25 +0000
@@ -99,9 +99,24 @@
     guint maximum_history_age;
     guint last_web_search;
 
+    struct _BookmarkbarDNDControl
+    {
+        GtkTargetList*  source_targets;
+        GtkTargetList*  dest_targets;
+
+        struct _BookmarkbarDragDestControl
+        {
+            GtkToolItem*    highligth_item;
+            gboolean hovering;
+            int n;
+        } drag_dest_control;
+    } bookmarkbar_dnd_control;
     gboolean bookmarkbar_populate;
 };
 
+typedef struct _BookmarkbarDNDControl BookmarkbarDNDControl;
+typedef struct _BookmarkbarDragDestControl BookmarkbarDragDestControl;
+
 G_DEFINE_TYPE (MidoriBrowser, midori_browser, GTK_TYPE_WINDOW)
 
 enum
@@ -173,11 +188,22 @@
 midori_bookmarkbar_populate (MidoriBrowser* browser);
 static void
 midori_bookmarkbar_populate_idle (MidoriBrowser* browser);
+void
+midori_bookmarkbar_position_items (GtkWidget* widget);
 
 static void
 midori_bookmarkbar_clear (GtkWidget* toolbar);
 
 static void
+bookmarkbar_dnd_control_init (BookmarkbarDNDControl* control, MidoriBrowser* browser);
+
+static void
+bookmarkbar_dnd_control_finalize (BookmarkbarDNDControl* control);
+
+static void
+bookmarkbar_dnd_control_install (BookmarkbarDNDControl* control, GtkToolbar* bookmarkbar);
+
+static void
 _midori_browser_set_toolbar_style (MidoriBrowser*     browser,
                                    MidoriToolbarStyle toolbar_style);
 
@@ -716,6 +742,8 @@
                           const gchar*   title)
 {
     const gchar* custom_title = midori_settings_get_custom_title (MIDORI_SETTINGS (browser->settings));
+    GtkAction* action = _action_by_name (browser, "Location");
+    midori_location_action_set_title (MIDORI_LOCATION_ACTION (action), title);
     if (custom_title && *custom_title)
         gtk_window_set_title (GTK_WINDOW (browser), custom_title);
     else if (katze_object_get_boolean (browser->settings, "enable-private-browsing"))
@@ -885,14 +913,14 @@
     gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
 
     renderer = gtk_cell_renderer_pixbuf_new ();
-    g_object_set (G_OBJECT (renderer), 
+    g_object_set (G_OBJECT (renderer),
         "stock-id", GTK_STOCK_DIRECTORY,
         "stock-size", GTK_ICON_SIZE_MENU,
         NULL);
     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
 
     renderer = katze_cell_renderer_combobox_text_new ();
-    g_object_set (G_OBJECT (renderer), 
+    g_object_set (G_OBJECT (renderer),
         "width-chars", 40,    /* FIXME: figure out a way to define an acceptable string length */
         "ellipsize", PANGO_ELLIPSIZE_END,
         "unfolded-text", _("Select [text]"),
@@ -916,7 +944,7 @@
             folders = g_list_append (folders, folder);
         }
 
-       	sqlite3_clear_bindings (statement);
+        sqlite3_clear_bindings (statement);
         sqlite3_reset (statement);
     }
 
@@ -1025,7 +1053,7 @@
 static gint64
 midori_bookmark_folder_button_get_active (GtkWidget* combo)
 {
-    gint64 id = 0;
+    gint64 id = -1;
     GtkTreeIter iter;
 
     g_return_val_if_fail (GTK_IS_COMBO_BOX (combo), 0);
@@ -1902,6 +1930,8 @@
     KatzeItem* item = midori_view_get_proxy_item (MIDORI_VIEW (view));
     guint n;
 
+    g_object_set (view, "dnd-targets", browser->bookmarkbar_dnd_control.source_targets, NULL);
+
     midori_browser_connect_tab (browser, view);
 
     if (!katze_item_get_meta_boolean (item, "append") &&
@@ -3107,29 +3137,17 @@
                                    KatzeArray*    folder,
                                    MidoriBrowser* browser)
 {
-    KatzeArray* bookmarks;
-    const gchar* id = katze_item_get_meta_string (KATZE_ITEM (folder), "id");
-    gchar* condition;
-
     if (browser->bookmarks == NULL)
         return FALSE;
 
-    if (id == NULL)
-        condition = "parentid is NULL";
-    else
-        condition = "parentid = %q";
-
-    bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
-        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
-    if (!bookmarks)
-        return FALSE;
+    midori_bookmarks_db_populate_folder (browser->bookmarks, folder);
 
     /* Clear items from dummy array here */
     gtk_container_foreach (GTK_CONTAINER (menu),
         (GtkCallback)(gtk_widget_destroy), NULL);
 
     /* "Import Bookmarks" and "Export Bookmarks" at the top */
-    if (id == NULL)
+    if (folder == KATZE_ARRAY (browser->bookmarks))
     {
         GtkWidget* menuitem;
         menuitem = gtk_action_create_menu_item (_action_by_name (browser, "BookmarksImport"));
@@ -3143,7 +3161,7 @@
         gtk_widget_show (menuitem);
     }
 
-    if (katze_array_is_empty (bookmarks))
+    if (katze_array_is_empty (folder))
     {
         GtkWidget* menuitem = gtk_image_menu_item_new_with_label (_("Empty"));
         gtk_widget_set_sensitive (menuitem, FALSE);
@@ -3152,7 +3170,7 @@
         return TRUE;
     }
 
-    katze_array_action_generate_menu (KATZE_ARRAY_ACTION (action), bookmarks,
+    katze_array_action_generate_menu (KATZE_ARRAY_ACTION (action), folder,
                                       menu, GTK_WIDGET (browser));
     return TRUE;
 }
@@ -4502,7 +4520,7 @@
 
     error = NULL;
     bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
-        "*", "parentid IS NULL", NULL, TRUE);
+        "*", "parentid IS NULL", NULL, NULL, TRUE);
     if (!midori_array_to_file (bookmarks, path, format, &error))
     {
         sokoke_message_dialog (GTK_MESSAGE_ERROR,
@@ -4903,6 +4921,8 @@
         uri = midori_view_get_display_uri (new_view);
     midori_browser_set_title (browser, midori_view_get_display_title (new_view));
     action = _action_by_name (browser, "Location");
+    midori_location_action_set_icon (MIDORI_LOCATION_ACTION (action), midori_view_get_icon_uri (new_view));
+    midori_location_action_set_title (MIDORI_LOCATION_ACTION (action), midori_view_get_display_title (new_view));
     midori_location_action_set_text (MIDORI_LOCATION_ACTION (action), uri);
     if (midori_paths_get_runtime_mode () == MIDORI_RUNTIME_MODE_APP)
         gtk_window_set_icon (GTK_WINDOW (browser), midori_view_get_icon (new_view));
@@ -5876,8 +5896,6 @@
     g_object_connect (action,
                       "signal::populate-popup",
                       _action_tools_populate_popup, browser,
-                      "signal::activate-item-alt",
-                      midori_bookmarkbar_activate_item_alt, browser,
                       NULL);
     gtk_action_group_add_action (browser->action_group, action);
     g_object_unref (action);
@@ -6003,7 +6021,11 @@
     g_signal_connect (browser->bookmarkbar, "popup-context-menu",
         G_CALLBACK (midori_browser_toolbar_popup_context_menu_cb), browser);
 
-    /* Create the panel */
+    bookmarkbar_dnd_control_init (&browser->bookmarkbar_dnd_control, browser);
+    bookmarkbar_dnd_control_install (&browser->bookmarkbar_dnd_control,
+                                     GTK_TOOLBAR (browser->bookmarkbar));
+
+   /* Create the panel */
     hpaned = gtk_hpaned_new ();
     g_signal_connect (hpaned, "notify::position",
                       G_CALLBACK (midori_panel_notify_position_cb),
@@ -6101,6 +6123,8 @@
 {
     MidoriBrowser* browser = MIDORI_BROWSER (object);
 
+    bookmarkbar_dnd_control_finalize (&browser->bookmarkbar_dnd_control);
+
     katze_assign (browser->statusbar_text, NULL);
 
     katze_object_assign (browser->settings, NULL);
@@ -6624,7 +6648,8 @@
 
 static void
 midori_bookmarkbar_insert_item (GtkWidget* toolbar,
-                                KatzeItem* item)
+                                KatzeItem* item,
+                                gint pos)
 {
     MidoriBrowser* browser = midori_browser_get_for_widget (toolbar);
     GtkAction* action = _action_by_name (browser, "Bookmarks");
@@ -6643,19 +6668,19 @@
     else /* Separator */
         gtk_tool_item_set_use_drag_window (toolitem, TRUE);
 
+    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, pos);
     gtk_widget_show (GTK_WIDGET (toolitem));
-    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
 }
 
 static void
 midori_bookmarkbar_add_item_cb (KatzeArray*    bookmarks,
-				KatzeItem*     item,
-				MidoriBrowser* browser)
+                KatzeItem*     item,
+                MidoriBrowser* browser)
 {
     if (gtk_widget_get_visible (browser->bookmarkbar))
         midori_bookmarkbar_populate (browser);
     else if (katze_item_get_meta_boolean (item, "toolbar"))
-	_action_set_active (browser, "Bookmarkbar", TRUE);
+    _action_set_active (browser, "Bookmarkbar", TRUE);
     midori_browser_update_history (item, "bookmark", "created");
 }
 
@@ -6702,7 +6727,7 @@
                         gtk_separator_tool_item_new (), -1);
 
     array = midori_bookmarks_db_query_recursive (browser->bookmarks,
-        "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
+        "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, "pos_bar ASC", FALSE);
     if (!array)
     {
         _action_set_sensitive (browser, "BookmarkAdd", FALSE);
@@ -6712,10 +6737,12 @@
 
     KATZE_ARRAY_FOREACH_ITEM (item, array)
     {
-        midori_bookmarkbar_insert_item (browser->bookmarkbar, item);
+        midori_bookmarkbar_insert_item (browser->bookmarkbar, item, -1);
     }
     _action_set_sensitive (browser, "BookmarkAdd", TRUE);
     _action_set_sensitive (browser, "BookmarkFolderAdd", TRUE);
+
+    midori_bookmarkbar_position_items (browser->bookmarkbar);
 }
 
 static void
@@ -6756,6 +6783,10 @@
             midori_bookmarkbar_remove_item_cb, browser);
     }
 
+    g_object_set (G_OBJECT (_action_by_name (browser, "Bookmarks")),
+        "array", KATZE_ARRAY (bookmarks),
+        NULL);
+
     settings = midori_browser_get_settings (browser);
     g_signal_handlers_disconnect_by_func (settings,
         midori_browser_show_bookmarkbar_notify_value_cb, browser);
@@ -7481,3 +7512,331 @@
 
     g_signal_emit (browser, signals[QUIT], 0);
 }
+
+static void
+bookmarkbar_drag_dest_control_init (BookmarkbarDragDestControl* control)
+{
+    control->highligth_item = NULL;
+    control->hovering = FALSE;
+}
+
+static GtkTargetEntry bookmarkbar_dnd_target_entries[]=
+{
+    {"KATZE_ARRAY", GTK_TARGET_SAME_APP, 0},
+};
+
+#define BOOKMARKBAR_DND_NB_TARGET_ENTRIES      \
+  G_N_ELEMENTS (bookmarkbar_dnd_target_entries)
+
+static void
+bookmarkbar_dnd_control_init (BookmarkbarDNDControl* control, MidoriBrowser* browser)
+{
+    bookmarkbar_drag_dest_control_init (&control->drag_dest_control);
+
+    control->source_targets = gtk_target_list_new (
+        bookmarkbar_dnd_target_entries, BOOKMARKBAR_DND_NB_TARGET_ENTRIES);
+    gtk_target_list_add_uri_targets (control->source_targets, 0);
+    gtk_target_list_add_text_targets (control->source_targets, 0);
+
+    control->dest_targets = gtk_target_list_new (
+        bookmarkbar_dnd_target_entries, BOOKMARKBAR_DND_NB_TARGET_ENTRIES);
+
+    g_object_set (_action_by_name (browser, "Bookmarks"), "dnd-targets", control->source_targets, NULL);
+    g_object_set (_action_by_name (browser, "Location"), "dnd-targets", control->source_targets, NULL);
+}
+
+static void
+bookmarkbar_dnd_control_finalize (BookmarkbarDNDControl* control)
+{
+    gtk_target_list_unref (control->source_targets);
+    gtk_target_list_unref (control->dest_targets);
+    control->source_targets = NULL;
+    control->dest_targets = NULL;
+}
+
+
+static GtkToolItem*
+bookmarkbar_drag_highlight_item (GdkDragContext *context)
+{
+
+    GtkToolItem* highlight_item = NULL;
+    GtkWidget* source = gtk_drag_get_source_widget (context);
+
+    if (source)
+    {
+        KatzeItem* item = (KatzeItem*)g_object_get_data (G_OBJECT (source), "KatzeItem");
+
+        if (!item && GTK_IS_TOOL_ITEM (gtk_widget_get_parent (source)))
+            item = (KatzeItem*)g_object_get_data (G_OBJECT (gtk_widget_get_parent (source)), "KatzeItem");
+
+        if (KATZE_ITEM_IS_BOOKMARK (item))
+            highlight_item = gtk_tool_button_new (NULL, "");
+        else if (KATZE_ITEM_IS_FOLDER (item))
+            highlight_item = gtk_toggle_tool_button_new ();
+
+        if (highlight_item)
+        {
+            GtkToolButton* toolbutton = GTK_TOOL_BUTTON (highlight_item);
+            GtkWidget* image = katze_item_get_image (item, GTK_WIDGET (highlight_item));
+            const gchar* title = katze_item_get_name (item);
+            GtkWidget* label = gtk_label_new (NULL);
+
+            gtk_widget_show (image);
+
+             if (!title || !*title)
+                title = katze_item_get_uri (item);
+
+           /* FIXME: Should text direction be respected here? */
+            gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+            gtk_label_set_max_width_chars (GTK_LABEL (label), 25);
+            gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
+            gtk_label_set_text (GTK_LABEL (label), title);
+            gtk_widget_show (label);
+
+            gtk_tool_button_set_icon_widget (toolbutton, image);
+            gtk_tool_button_set_label_widget (toolbutton, label);
+
+            gtk_tool_item_set_visible_horizontal (highlight_item, TRUE);
+            gtk_tool_item_set_visible_vertical (highlight_item, TRUE);
+            gtk_tool_item_set_is_important (highlight_item, TRUE);
+        }
+    }
+
+    if (!highlight_item)
+        highlight_item = gtk_separator_tool_item_new ();
+
+    gtk_widget_show (GTK_WIDGET (highlight_item));
+    return highlight_item;
+}
+
+static gboolean
+bookmarkbar_drag_dest_drag_motion_cb (GtkWidget *widget,
+                                      GdkDragContext *context,
+                                      gint x, gint y, guint t,
+                                      BookmarkbarDragDestControl* control)
+{
+    GtkToolbar* toolbar = GTK_TOOLBAR (widget);
+    gint n = gtk_toolbar_get_drop_index (toolbar, x, y);
+
+    if (!control->highligth_item)
+    {
+        GtkToolItem* highlight_item = bookmarkbar_drag_highlight_item (context);
+        g_object_ref (highlight_item);
+
+        gtk_toolbar_set_drop_highlight_item (toolbar,
+                                             highlight_item,
+                                             n);
+        control->highligth_item = highlight_item;
+        control->n = n;
+    }
+    else if (n != control->n)
+    {
+        gtk_toolbar_set_drop_highlight_item (toolbar,
+                         control->highligth_item,
+                         n);
+        control->n = n;
+    }
+    return  FALSE;
+}
+
+static void
+bookmarkbar_drag_dest_drag_leave_cb (GtkWidget *widget,
+                                     GdkDragContext *context,
+                                     guint time,
+                                     BookmarkbarDragDestControl* control)
+{
+    GtkToolbar* toolbar = GTK_TOOLBAR (widget);
+
+    if (control->highligth_item)
+    {
+        gtk_toolbar_set_drop_highlight_item (toolbar, NULL, -1);
+        g_object_unref (control->highligth_item);
+        control->highligth_item = NULL;
+    }
+}
+
+void
+midori_bookmarkbar_position_items (GtkWidget        *widget)
+{
+    GtkToolbar* toolbar = GTK_TOOLBAR (widget);
+    MidoriBrowser* browser = midori_browser_get_for_widget (widget);
+    gint n = gtk_toolbar_get_n_items (toolbar);
+    gint i;
+    gint pos;
+
+    pos = 0;
+    for (i = 0; i < n ; i++ )
+    {
+        GtkWidget* toolitem = GTK_WIDGET (gtk_toolbar_get_nth_item (toolbar, i));
+        KatzeItem* local_item = (KatzeItem*)g_object_get_data (G_OBJECT (toolitem), "KatzeItem");
+
+        if (!KATZE_IS_ITEM (local_item))
+            continue;
+
+        if (pos != katze_item_get_meta_integer (local_item, "pos_bar"))
+            katze_item_set_meta_integer (local_item, "pos_bar", pos);
+
+        midori_bookmarks_db_update_item (browser->bookmarks, local_item);
+
+        pos++;
+    }
+}
+
+static void
+bookmarkbar_drag_dest_drag_data_received_cb (GtkWidget        *widget,
+                                             GdkDragContext   *drag_context,
+                                             gint             x,
+                                             gint             y,
+                                             GtkSelectionData *data,
+                                             guint            info,
+                                             guint            time,
+                                             BookmarkbarDragDestControl* control)
+{
+    GtkToolbar* toolbar = GTK_TOOLBAR (widget);
+    MidoriBrowser* browser = midori_browser_get_for_widget (widget);
+    gboolean success = FALSE;
+    gboolean delete = FALSE;
+
+    g_assert (browser);
+
+    g_signal_handlers_block_by_func (browser->bookmarks,
+        midori_bookmarkbar_add_item_cb, browser);
+    g_signal_handlers_block_by_func (browser->bookmarks,
+        midori_bookmarkbar_update_item_cb, browser);
+    g_signal_handlers_block_by_func (browser->bookmarks,
+        midori_bookmarkbar_remove_item_cb, browser);
+
+    if (gtk_selection_data_get_length (data) >= 0)
+    {
+        switch (gdk_drag_context_get_selected_action (drag_context))
+        {
+            case GDK_ACTION_MOVE:
+               delete = TRUE;
+            case GDK_ACTION_COPY:
+                if (gtk_selection_data_get_format (data) == 8)
+                {
+                    KatzeArray *array = katze_array_from_selection_data (data);
+
+                    if (array)
+                    {
+                        KatzeItem *item;
+                        KATZE_ARRAY_FOREACH_ITEM (item, array)
+                        {
+                            gint old_pos = gtk_toolbar_get_n_items(toolbar);
+                            gint dest_pos = gtk_toolbar_get_drop_index (toolbar, x, y);
+                            gboolean is_bookmark = katze_item_get_meta_string (item, "id") ? TRUE : FALSE ;
+                            gboolean from_toolbar =  is_bookmark && katze_item_get_meta_boolean (item, "toolbar");
+
+                            if (midori_debug("bookmarks"))
+                            {
+                                g_print ("bookmarkbar received KATZE_ITEM(bookmark:%d, toolbar:%d, title:%s) \n",
+                                    is_bookmark, from_toolbar, katze_item_get_name (item));
+                            }
+
+                            if (from_toolbar)
+                            {
+                                GtkToolItem* toolitem = NULL;
+                                KatzeItem* local_item = NULL;
+
+                                old_pos = katze_item_get_meta_integer (item, "pos_bar");
+
+                                if ((dest_pos != old_pos)
+                                    && (toolitem = gtk_toolbar_get_nth_item (toolbar,
+                                            old_pos))
+                                    && (local_item = (KatzeItem*)g_object_get_data (
+                                            G_OBJECT (toolitem), "KatzeItem")))
+                                {
+                                    midori_bookmarkbar_insert_item (widget,
+                                        local_item, dest_pos);
+
+                                    if (old_pos < dest_pos)
+                                        old_pos++;
+
+                                    /* FIXME: force a move */
+                                    delete = TRUE;
+                                }
+                                else
+                                    delete = FALSE;
+                            }
+                            else if (!is_bookmark)
+                            {
+                                item = katze_item_copy (item);
+
+                                katze_item_set_meta_integer (item, "toolbar", TRUE);
+
+                                midori_bookmarkbar_insert_item (widget,
+                                    item, dest_pos);
+
+                                midori_bookmarks_db_add_item (browser->bookmarks, item);
+
+                                if (old_pos > dest_pos)
+                                    old_pos++;
+
+                                delete = FALSE;
+                            }
+                            else
+                            {
+                                katze_item_set_meta_integer (item, "toolbar", TRUE);
+
+                                midori_bookmarkbar_insert_item (widget,
+                                    item, dest_pos);
+
+                                if (old_pos > dest_pos)
+                                    old_pos++;
+
+                                delete = FALSE;
+                            }
+                        }
+
+                        g_object_unref (array);
+                        success = TRUE;
+                        break;
+                    }
+                }
+            default:
+                break;
+        }
+    }
+
+    if (!success)
+        delete = FALSE;
+
+    gtk_drag_finish (drag_context, success, delete, time);
+
+    if (success && !delete)
+    {
+        midori_bookmarkbar_position_items (GTK_WIDGET (toolbar));
+    }
+
+    g_signal_handlers_unblock_by_func (browser->bookmarks,
+        midori_bookmarkbar_add_item_cb, browser);
+    g_signal_handlers_unblock_by_func (browser->bookmarks,
+        midori_bookmarkbar_update_item_cb, browser);
+    g_signal_handlers_unblock_by_func (browser->bookmarks,
+        midori_bookmarkbar_remove_item_cb, browser);
+}
+
+static void
+bookmarkbar_drag_dest_control_install (BookmarkbarDNDControl* control,
+                                       GtkToolbar* bookmarkbar)
+{
+    GtkWidget* widget = GTK_WIDGET (bookmarkbar);
+    gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_ALL, NULL, 0,
+                       GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_LINK);
+    gtk_drag_dest_set_target_list (widget, control->dest_targets);
+    g_signal_connect (bookmarkbar, "drag-motion",
+        G_CALLBACK (bookmarkbar_drag_dest_drag_motion_cb),
+        &control->drag_dest_control);
+    g_signal_connect (bookmarkbar, "drag-leave",
+        G_CALLBACK (bookmarkbar_drag_dest_drag_leave_cb),
+        &control->drag_dest_control);
+    g_signal_connect (bookmarkbar, "drag-data-received",
+        G_CALLBACK (bookmarkbar_drag_dest_drag_data_received_cb),
+        &control->drag_dest_control);
+}
+
+static void
+bookmarkbar_dnd_control_install (BookmarkbarDNDControl* control, GtkToolbar* bookmarkbar)
+{
+    bookmarkbar_drag_dest_control_install (control, bookmarkbar);
+}
 
=== modified file 'midori/midori-locationaction.c'
--- midori/midori-locationaction.c	2013-11-05 14:51:49 +0000
+++ midori/midori-locationaction.c	2014-01-26 19:44:25 +0000
@@ -43,6 +43,8 @@
     gint completion_index;
     GtkWidget* entry;
     KatzeArray* history;
+    KatzeItem* item;
+    GtkTargetList*  dnd_targets;
 };
 
 struct _MidoriLocationActionClass
@@ -58,7 +60,8 @@
 
     PROP_PROGRESS,
     PROP_SECONDARY_ICON,
-    PROP_HISTORY
+    PROP_HISTORY,
+    PROP_DND_TARGETS
 };
 
 enum
@@ -222,6 +225,22 @@
                                      "The list of history items",
                                      KATZE_TYPE_ARRAY,
                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+    /**
+     * MidoriLocationAction:dnd-targets:
+     *
+     * GtkTargetList* the location action supports.
+     *
+     * Since: 0.5.2
+     **/
+    g_object_class_install_property (gobject_class,
+                                     PROP_DND_TARGETS,
+                                     g_param_spec_pointer (
+                                     "dnd-targets",
+                                     "DNDTargets",
+        "GtkTargetList* the location action supports",
+                                     G_PARAM_READABLE|G_PARAM_WRITABLE));
+
 }
 
 gchar*
@@ -813,6 +832,8 @@
 {
     location_action->progress = 0.0;
     location_action->completion_index = -1;
+    location_action->item = katze_item_new ();
+    location_action->dnd_targets = NULL;
 }
 
 static void
@@ -832,6 +853,8 @@
     }
     katze_object_assign (location_action->history, NULL);
 
+    g_object_unref (location_action->item);
+
     G_OBJECT_CLASS (midori_location_action_parent_class)->finalize (object);
 }
 
@@ -858,6 +881,9 @@
         katze_assign (location_action->history, g_value_dup_object (value));
         break;
     }
+    case PROP_DND_TARGETS:
+        location_action->dnd_targets = (GtkTargetList*)g_value_get_pointer (value);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -883,6 +909,9 @@
     case PROP_HISTORY:
         g_value_set_object (value, location_action->history);
         break;
+    case PROP_DND_TARGETS:
+        g_value_set_pointer (value, location_action->dnd_targets);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -917,20 +946,19 @@
                                                GtkSelectionData* data,
                                                guint             info,
                                                guint32           time,
-                                               GtkAction*        action)
+                                               MidoriLocationAction* action)
 {
     if (gtk_entry_get_current_icon_drag_source (GTK_ENTRY (entry)) == GTK_ENTRY_ICON_PRIMARY)
     {
-        const gchar* uri = gtk_entry_get_text (GTK_ENTRY (entry));
-        gchar** uris = g_strsplit (uri, uri, 1);
-        gtk_selection_data_set_uris (data, uris);
-        g_strfreev (uris);
+        katze_item_set_uri (action->item, gtk_entry_get_text (GTK_ENTRY (entry)));
+        selection_data_from_katze_item (data, action->item);
     }
 }
 
 static GtkWidget*
 midori_location_action_create_tool_item (GtkAction* action)
 {
+    MidoriLocationAction* location_action = MIDORI_LOCATION_ACTION (action);
     GtkWidget* toolitem;
     GtkWidget* alignment;
     GtkWidget* entry;
@@ -953,10 +981,18 @@
     gtk_entry_set_icon_activatable (GTK_ENTRY (entry),
          GTK_ENTRY_ICON_SECONDARY, TRUE);
 
-    targetlist = gtk_target_list_new (NULL, 0);
-    gtk_target_list_add_uri_targets (targetlist, 0);
-    gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, targetlist, GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK);
-    gtk_target_list_unref (targetlist);
+    g_object_set_data (G_OBJECT (entry), "KatzeItem", MIDORI_LOCATION_ACTION (action)->item);
+
+    if (location_action->dnd_targets)
+        gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, 
+            location_action->dnd_targets, GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK);
+    else
+    {
+        targetlist = gtk_target_list_new (NULL, 0);
+        gtk_target_list_add_uri_targets (targetlist, 0);
+        gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, targetlist, GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK);
+        gtk_target_list_unref (targetlist);
+    }
     g_signal_connect (entry, "drag-data-get",
         G_CALLBACK (midori_location_action_entry_drag_data_get_cb), action);
     gtk_widget_show (entry);
@@ -1630,6 +1666,38 @@
 }
 
 /**
+ * midori_location_action_set_icon:
+ * @location_action: a #MidoriLocationAction
+ * @icon: an icon
+ *
+ * Sets the entry icon to @icon.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_location_action_set_icon (MidoriLocationAction* location_action,
+                                  const gchar*          icon)
+{
+    katze_item_set_icon (location_action->item, icon);
+}
+
+/**
+ * midori_location_action_set_title:
+ * @location_action: a #MidoriLocationAction
+ * @text: a string
+ *
+ * Sets the entry name to @text.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_location_action_set_title (MidoriLocationAction* location_action,
+                                  const gchar*          title)
+{
+    katze_item_set_name (location_action->item, title);
+}
+
+/**
  * midori_location_action_set_text:
  * @location_action: a #MidoriLocationAction
  * @text: a string
 
=== modified file 'midori/midori-locationaction.h'
--- midori/midori-locationaction.h	2013-04-16 23:10:10 +0000
+++ midori/midori-locationaction.h	2014-01-26 19:44:25 +0000
@@ -40,6 +40,14 @@
 midori_location_action_get_text             (MidoriLocationAction* location_action);
 
 void
+midori_location_action_set_icon             (MidoriLocationAction* location_action,
+                                             const gchar*          icon);
+
+void
+midori_location_action_set_title            (MidoriLocationAction* location_action,
+                                             const gchar*          title);
+
+void
 midori_location_action_set_text             (MidoriLocationAction* location_action,
                                              const gchar*          text);
 
 
=== modified file 'midori/midori-view.c'
--- midori/midori-view.c	2013-12-09 20:23:03 +0000
+++ midori/midori-view.c	2014-01-26 19:44:25 +0000
@@ -121,6 +121,8 @@
     GtkWidget* overlay_label;
     GtkWidget* overlay_find;
     #endif
+
+    GtkTargetList*  dnd_targets;
 };
 
 struct _MidoriViewClass
@@ -139,7 +141,8 @@
     PROP_MINIMIZED,
     PROP_ZOOM_LEVEL,
     PROP_NEWS_FEEDS,
-    PROP_SETTINGS
+    PROP_SETTINGS,
+    PROP_DND_TARGETS
 };
 
 enum {
@@ -379,6 +382,21 @@
                                      MIDORI_TYPE_WEB_SETTINGS,
                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
+    /**
+     * MidoriView:dnd-targets:
+     *
+     * GtkTargetList* the view supports.
+     *
+     * Since: 0.5.2
+     **/
+    g_object_class_install_property (gobject_class,
+                                     PROP_DND_TARGETS,
+                                     g_param_spec_pointer (
+                                     "dnd-targets",
+                                     "DNDTargets",
+        "GtkTargetList* the view supports",
+                                     G_PARAM_READABLE|G_PARAM_WRITABLE));
+
     #ifdef HAVE_WEBKIT2
     WebKitWebContext* context = webkit_web_context_get_default ();
     webkit_web_context_register_uri_scheme (context,
@@ -2983,6 +3001,8 @@
     view->news_feeds = NULL;
     view->find_links = -1;
     view->alerts = 0;
+    view->dnd_targets = NULL;
+
 
     view->item = katze_item_new ();
 
@@ -3056,6 +3076,9 @@
     case PROP_SETTINGS:
         _midori_view_set_settings (view, g_value_get_object (value));
         break;
+    case PROP_DND_TARGETS:
+        view->dnd_targets = (GtkTargetList*)g_value_get_pointer (value);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -3087,6 +3110,9 @@
     case PROP_SETTINGS:
         g_value_set_object (value, view->settings);
         break;
+    case PROP_DND_TARGETS:
+        g_value_set_pointer (value, view->dnd_targets);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -4296,6 +4322,89 @@
     return new_view;
 }
 
+#if 0
+static void
+midori_view_tab_label_data_received (GtkWidget* widget,
+                                     GdkDragContext* context,
+                                     gint x,
+                                     gint y,
+                                     GtkSelectionData* data,
+                                     guint ttype,
+                                     guint timestamp,
+                                     MidoriView* view)
+{
+    KatzeArray *array;
+    gchar** uri;
+
+    array = katze_array_from_selection_data (data);
+    if (array) 
+    {
+        if (katze_array_get_length (array))
+        {
+            KatzeItem* item = katze_array_get_nth_item (array, 0);
+            if (KATZE_ITEM_IS_BOOKMARK (item))
+            {
+                midori_view_set_title (view, katze_item_get_name (item));
+                midori_view_set_uri (view, katze_item_get_uri (item));
+            }
+        }
+
+        g_object_unref (array);
+        return;
+    }
+
+    uri = gtk_selection_data_get_uris (data);
+    if (uri != NULL)
+    {
+        midori_view_set_uri (view, uri[0]);
+        g_strfreev (uri);
+    }
+    else
+    {
+        gchar* text = (gchar*) gtk_selection_data_get_text (data);
+        midori_view_set_uri (view, text);
+        g_free (text);
+    }
+}
+
+static void
+midori_view_tab_label_data_get (GtkWidget *widget,
+                                GdkDragContext *drag_context,
+                                GtkSelectionData *data,
+                                guint info,
+                                guint time,
+                                MidoriView* view)
+{
+    selection_data_from_katze_item (data, view->item);
+}
+
+static void
+midori_view_install_tab_dnd (MidoriView* view, GtkWidget* widget)
+{
+    g_object_set_data (G_OBJECT (widget), "KatzeItem", view->item)
+;
+    gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_ALL, NULL,
+        0, GDK_ACTION_COPY);
+    if (view->dnd_targets)
+        gtk_drag_dest_set_target_list (widget, view->dnd_targets);
+    gtk_drag_dest_add_text_targets (widget);
+    gtk_drag_dest_add_uri_targets (widget);
+    g_signal_connect (widget, "drag-data-received",
+        G_CALLBACK (midori_view_tab_label_data_received),
+        view);
+    if (view->dnd_targets)
+    {
+        g_print ("midori_view_get_tab: install source widget\n");
+        gtk_drag_source_set (widget, GDK_BUTTON1_MASK, NULL, 0,
+            GDK_ACTION_COPY|GDK_ACTION_LINK);
+        gtk_drag_source_set_target_list (widget, view->dnd_targets);
+        g_signal_connect (widget, "drag-data-get",
+            G_CALLBACK (midori_view_tab_label_data_get), 
+            view);
+    }
+}
+#endif
+
 /**
  * midori_view_get_tab_menu:
  * @view: a #MidoriView
 
=== modified file 'panels/midori-bookmarks.c'
--- panels/midori-bookmarks.c	2014-01-24 23:04:05 +0000
+++ panels/midori-bookmarks.c	2014-01-26 19:44:25 +0000
@@ -26,6 +26,151 @@
 
 #define COMPLETION_DELAY 200
 
+#define MIDORI_BOOKMARKS_TREE_MODEL_TARGET "GTK_TREE_MODEL_ROW"
+
+G_BEGIN_DECLS
+
+#define MIDORI_BOOKMARKS_TREE_STORE_TYPE \
+    (midori_bookmarks_tree_store_get_type ())
+#define MIDORI_BOOKMARKS_TREE_STORE(obj) \
+    (G_TYPE_CHECK_INSTANCE_CAST ((obj), MIDORI_BOOKMARKS_TREE_STORE_TYPE, MidoriBookmarksTreeStore))
+#define MIDORI_BOOKMARKS_TREE_STORE_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST ((klass), MIDORI_BOOKMARKS_TREE_STORE_TYPE, MidoriBookmarksTreeStoreClass))
+
+static gboolean
+midori_bookmarks_tree_store_drag_data_get (GtkTreeDragSource*  drag_source,
+                                           GtkTreePath*      source_path,
+                                           GtkSelectionData* selection_data);
+static gboolean
+midori_bookmarks_tree_store_drag_data_delete (GtkTreeDragSource*  drag_source,
+                                              GtkTreePath*      source_path);
+static gboolean
+midori_bookmarks_tree_store_row_drop_possible (GtkTreeDragDest   *drag_dest,
+                                               GtkTreePath       *dest_path,
+                                               GtkSelectionData  *selection_data);
+static gboolean
+midori_bookmarks_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
+                                                GtkTreePath       *dest_path,
+                                                GtkSelectionData  *selection_data);
+
+typedef struct _MidoriBookmarksTreeStore                MidoriBookmarksTreeStore;
+typedef struct _MidoriBookmarksTreeStoreClass           MidoriBookmarksTreeStoreClass;
+typedef struct _TreeRowData TreeRowData;
+
+struct _MidoriBookmarksTreeStore
+{
+    GtkTreeStore parent_instance;
+
+    GList* stock_got_rows;
+    GtkTreeView *_view;
+};
+
+struct _MidoriBookmarksTreeStoreClass
+{
+    GtkTreeStoreClass parent_class;
+};
+
+struct _TreeRowData
+{
+    GtkTreeModel *model;
+    gchar path[4];
+};
+
+static GtkTreeDragSourceIface *
+gtk_tree_store_gtk_tree_drag_source_iface = NULL;
+static GtkTreeDragDestIface *
+gtk_tree_store_gtk_tree_drag_dest_iface = NULL;
+
+static void
+midori_bookmarks_tree_store_drag_source_init (GtkTreeDragSourceIface *iface)
+{
+    gtk_tree_store_gtk_tree_drag_source_iface = g_type_interface_peek_parent (iface);
+
+    iface->drag_data_get = midori_bookmarks_tree_store_drag_data_get;
+    iface->drag_data_delete = midori_bookmarks_tree_store_drag_data_delete;
+}
+
+static void
+midori_bookmarks_tree_store_drag_dest_init (GtkTreeDragDestIface *iface)
+{
+    gtk_tree_store_gtk_tree_drag_dest_iface = g_type_interface_peek_parent (iface);
+
+    iface->row_drop_possible = midori_bookmarks_tree_store_row_drop_possible;
+    iface->drag_data_received = midori_bookmarks_tree_store_drag_data_received;
+}
+
+static void
+midori_bookmarks_tree_store_init (MidoriBookmarksTreeStore* item)
+{
+    item->stock_got_rows = NULL;
+    item->_view = NULL;
+}
+
+static void
+midori_bookmarks_tree_store_class_init (MidoriBookmarksTreeStoreClass *class)
+{
+}
+
+G_DEFINE_TYPE_WITH_CODE (MidoriBookmarksTreeStore,
+                         midori_bookmarks_tree_store,
+                         GTK_TYPE_TREE_STORE,
+                         G_IMPLEMENT_INTERFACE (
+                             GTK_TYPE_TREE_DRAG_SOURCE,
+                             midori_bookmarks_tree_store_drag_source_init)
+                         G_IMPLEMENT_INTERFACE (
+                             GTK_TYPE_TREE_DRAG_DEST,
+                             midori_bookmarks_tree_store_drag_dest_init));
+
+
+GtkTreeStore*
+midori_bookmarks_tree_store_new (gint n_columns, ...)
+{
+    GtkTreeStore* tree_store = GTK_TREE_STORE (g_object_new (MIDORI_BOOKMARKS_TREE_STORE_TYPE, NULL));
+    va_list ap;
+    GType* types;
+    gint n;
+
+    if (!tree_store)
+        return NULL;
+
+    types = g_new (GType, n_columns);
+
+    if (!types)
+    {
+        g_object_unref(tree_store);
+        return NULL;
+    }
+
+    va_start(ap, n_columns);
+    for (n = 0; n < n_columns; n++)
+    {
+        types[n] = va_arg(ap, GType);
+    }
+    va_end(ap);
+
+    gtk_tree_store_set_column_types (tree_store,
+        n_columns,
+        types);
+
+    g_free (types);
+    return tree_store;
+}
+
+GtkTreeStore*
+midori_bookmarks_tree_store_newv (gint n_columns, GType *types)
+{
+    GtkTreeStore* tree_store = GTK_TREE_STORE (g_object_new (MIDORI_BOOKMARKS_TREE_STORE_TYPE, NULL));
+
+    if (!tree_store)
+        return NULL;
+
+    gtk_tree_store_set_column_types (tree_store,
+        n_columns,
+        types);
+
+    return tree_store;
+}
+
 gboolean
 midori_browser_edit_bookmark_dialog_new (MidoriBrowser* browser,
                                          KatzeItem*     bookmark_or_parent,
@@ -37,6 +182,12 @@
 midori_browser_open_bookmark (MidoriBrowser* browser,
                               KatzeItem*     item);
 
+static void
+midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
+                                 GtkTreePath*     path,
+                                 GtkTreeIter*     iter,
+                                 MidoriBookmarks* bookmarks);
+
 struct _MidoriBookmarks
 {
     GtkVBox parent_instance;
@@ -50,7 +201,19 @@
     gint filter_timeout;
     gchar* filter;
 
+    GList* pending_inserts;
     KatzeItem* hovering_item;
+
+    struct _stock_pending_event
+    {
+        gint x;
+        gint y;
+    } *pending_event,
+        stock_pending_event;
+
+    GHashTable* updated_items;
+    GList* added_paths;
+    GList* reordered_paths;
 };
 
 struct _MidoriBookmarksClass
@@ -88,36 +251,47 @@
                                GParamSpec* pspec);
 
 static void
-midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
-                                 GtkTreePath*     path,
-                                 GtkTreeIter*     iter,
-                                 MidoriBookmarks* bookmarks);
-
+midori_bookmarks_update_cb (KatzeArray*      array,
+                            MidoriBookmarks* bookmarks);
 static void
 midori_bookmarks_add_item_cb (KatzeArray*      array,
                               KatzeItem*       item,
                               MidoriBookmarks* bookmarks);
-
 static void
 midori_bookmarks_update_item_cb (KatzeArray*      array,
-				 KatzeItem*       item,
-				 MidoriBookmarks* bookmarks);
-
+                                 KatzeItem*       item,
+                                 MidoriBookmarks* bookmarks);
 static void
 midori_bookmarks_remove_item_cb (KatzeArray*      array,
                                  KatzeItem*       item,
                                  MidoriBookmarks* bookmarks);
 
 static void
-midori_bookmarks_update_cb (KatzeArray*      array,
-                            MidoriBookmarks* bookmarks);
+midori_bookmarks_row_inserted_cb (GtkTreeModel*    model,
+			                      GtkTreePath*     path,
+			                      GtkTreeIter*     iter,
+			                      MidoriBookmarks* bookmarks);
+static void
+midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
+                                 GtkTreePath*     path,
+                                 GtkTreeIter*     iter,
+                                 MidoriBookmarks* bookmarks);
+static void
+midori_bookmarks_row_deleted_cb (GtkTreeModel*    model,
+                                 GtkTreePath*     path,
+                                 MidoriBookmarks* bookmarks);
+
+static void
+midori_bookmarks_update_item (MidoriBookmarks* bookmarks, KatzeItem *item);
 
 static void
 midori_bookmarks_statusbar_update (MidoriBookmarks *bookmarks);
 
 static void
-midori_bookmarks_add_item (KatzeItem*       item,
-                           MidoriBookmarks* bookmarks);
+midori_bookmarks_idle_remove_item (MidoriBookmarks* bookmarks, KatzeItem *item);
+
+static gboolean
+midori_bookmarks_idle_func (gpointer data);
 
 static void
 midori_bookmarks_class_init (MidoriBookmarksClass* class)
@@ -133,13 +307,13 @@
     flags = G_PARAM_READWRITE | G_PARAM_CONSTRUCT;
 
     g_object_class_install_property (gobject_class,
-                                     PROP_APP,
-                                     g_param_spec_object (
-                                     "app",
-                                     "App",
-                                     "The app",
-                                     MIDORI_TYPE_APP,
-                                     flags));
+        PROP_APP,
+        g_param_spec_object (
+            "app",
+            "App",
+            "The app",
+            MIDORI_TYPE_APP,
+            flags));
 }
 
 static const gchar*
@@ -168,7 +342,7 @@
     gchar* parent_id;
 
     parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    if (!(root_array = midori_bookmarks_db_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
+    if (!(root_array = midori_bookmarks_db_query_recursive (array, "*", "parentid = %q", parent_id, "(uri='') ASC, pos_panel DESC", FALSE)))
     {
         g_free (parent_id);
         return;
@@ -180,7 +354,7 @@
             subarray = katze_array_new (KATZE_TYPE_ARRAY);
             katze_item_set_name (KATZE_ITEM (subarray), katze_item_get_name (item));
             midori_bookmarks_export_array_db (db, subarray,
-                    katze_item_get_meta_integer (item, "parentid"));
+                katze_item_get_meta_integer (item, "parentid"));
             katze_array_add_item (array, subarray);
         }
         else
@@ -201,20 +375,20 @@
 
     if (keyword && *keyword)
         array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
-                                                     "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
+            "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, NULL, FALSE);
     else
     {
         if (parentid > 0)
         {
             gchar* parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
             array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
-                                                         "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, "(uri='') ASC, pos_panel DESC", FALSE);
 
             g_free (parent_id);
         }
         else
             array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
-                                                         "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, "(uri='') ASC, pos_panel DESC", FALSE);
     }
     return array ? array : katze_array_new (KATZE_TYPE_ITEM);
 }
@@ -231,24 +405,52 @@
     KatzeItem* item;
     GtkTreeIter child;
 
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_changed_cb,
+        bookmarks);
+
     array = midori_bookmarks_read_from_db (bookmarks, parentid, keyword);
     katze_bookmark_populate_tree_view (array, model, parent);
+
+    g_signal_handlers_unblock_by_func (model,
+        midori_bookmarks_row_changed_cb,
+        bookmarks);
+
     /* Remove invisible dummy row */
     last = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), parent);
     if (!last)
         return;
+
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
     gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model), &child, parent, last - 1);
     gtk_tree_model_get (GTK_TREE_MODEL (model), &child, 0, &item, -1);
     if (KATZE_ITEM_IS_SEPARATOR (item))
         gtk_tree_store_remove (model, &child);
     else
         g_object_unref (item);
+
+    g_signal_handlers_unblock_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
 }
 
+static void
+midori_bookmarks_add_item (KatzeItem*       item,
+                           MidoriBookmarks* bookmarks);
+
+static void
+add_parent_to_reorder (GtkTreeModel*    model,
+			           GtkTreePath*     path,
+                       MidoriBookmarks* bookmarks);
+
 static gboolean
 midori_bookmarks_reach_item_recurse (GtkTreeModel* model,
-				     GtkTreeIter* iter,
-				     gint64 id)
+                                     GtkTreeIter* iter,
+                                     gint64 id)
 {
     do
     {
@@ -258,7 +460,7 @@
 
         gtk_tree_model_get (model, iter, 0, &item, -1);
 
-        if (!KATZE_ITEM_IS_SEPARATOR(item))
+        if (item)
         {
             itemid = katze_item_get_meta_integer (item, "id");
             g_object_unref (item);
@@ -267,13 +469,11 @@
         if (id == itemid)
             return TRUE;
 
-        if (gtk_tree_model_iter_children (model, &child, iter))
+        if (gtk_tree_model_iter_children (model, &child, iter)
+            && midori_bookmarks_reach_item_recurse (model, &child, id))
         {
-            if (midori_bookmarks_reach_item_recurse (model, &child, id))
-            {
-                *iter = child;
-                return TRUE;
-            }
+            *iter = child;
+            return TRUE;
         }
     }
     while (gtk_tree_model_iter_next(model, iter));
@@ -283,8 +483,8 @@
 
 static gboolean
 midori_bookmarks_reach_item (GtkTreeModel* model,
-			     GtkTreeIter* iter,
-			     gint64 id)
+                             GtkTreeIter* iter,
+                             gint64 id)
 {
     if (!gtk_tree_model_get_iter_first(model, iter))
         return FALSE;
@@ -293,38 +493,73 @@
 }
 
 static void
-midori_bookmarks_add_item_to_model(GtkTreeStore*    model,
-				   GtkTreeIter*     parent,
-				   KatzeItem*       item)
+midori_bookmarks_add_item_to_model(MidoriBookmarks* bookmarks,
+				                   GtkTreeModel*    model,
+                                   GtkTreeIter*     parent,
+                                   KatzeItem*       item)
 {
+    GtkTreeStore* tree_store = GTK_TREE_STORE (model);
+    gint last;
+    GtkTreeIter child;
+
     if (KATZE_ITEM_IS_BOOKMARK (item))
     {
+        gint position = 0;
+
+        /* skip the folders to be consistent with the db query order */
+        if (gtk_tree_model_iter_children (model, &child, parent))
+            while (gtk_tree_model_iter_has_child (model, &child))
+            {
+                position++;
+                if (!gtk_tree_model_iter_next (model, &child))
+                    break;
+            }
+
         gchar* tooltip = g_markup_escape_text (katze_item_get_uri (item), -1);
 
-        gtk_tree_store_insert_with_values (model, NULL, parent,
-            0,
+        gtk_tree_store_insert_with_values (tree_store, NULL, parent,
+            position,
             0, item, 1, tooltip, -1);
         g_free (tooltip);
     }
-    else
+    else if (KATZE_ITEM_IS_FOLDER (item))
     {
         GtkTreeIter root_iter;
 
-        gtk_tree_store_insert_with_values (model, &root_iter, parent,
+        gtk_tree_store_insert_with_values (tree_store, &root_iter, parent,
             0, 0, item, -1);
 
         /* That's an invisible dummy, so we always have an expander */
-        gtk_tree_store_insert_with_values (model, NULL, &root_iter,
-            0,
-            0, NULL, -1);
+        gtk_tree_store_insert_with_values (tree_store, NULL, &root_iter,
+            0, 0, NULL, -1);
     }
+
+    /* Remove invisible dummy row */
+    last = gtk_tree_model_iter_n_children (model, parent);
+    if (!last)
+        return;
+
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
+    gtk_tree_model_iter_nth_child (model, &child, parent, last - 1);
+    gtk_tree_model_get (model, &child, 0, &item, -1);
+    if (KATZE_ITEM_IS_SEPARATOR (item))
+        gtk_tree_store_remove (tree_store, &child);
+    else
+        g_object_unref (item);
+
+    g_signal_handlers_unblock_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
 }
 
 static void
 midori_bookmarks_update_item_in_model(MidoriBookmarks* bookmarks,
-				      GtkTreeStore*    model,
-				      GtkTreeIter*     iter,
-				      KatzeItem*       item)
+                                      GtkTreeStore*    model,
+                                      GtkTreeIter*     iter,
+                                      KatzeItem*       item)
 {
     g_signal_handlers_block_by_func (model,
         midori_bookmarks_row_changed_cb,
@@ -350,18 +585,48 @@
         bookmarks);
 }
 
+static gboolean
+midori_bookmarks_idle_pending (MidoriBookmarks* bookmarks)
+{
+    if (bookmarks->pending_inserts
+        || bookmarks->added_paths
+        || bookmarks->reordered_paths
+        || g_hash_table_size (bookmarks->updated_items))
+        return TRUE;
+    return FALSE;
+}
+
+/**
+ * midori_bookmarks_idle_start:
+ * @bookmarks: the bookmarks panel
+ *
+ * Internal function that checks whether idle processing is pending,
+ * if not, add a new one.
+ **/
+static void
+midori_bookmarks_idle_start (MidoriBookmarks* bookmarks)
+{
+    if (midori_bookmarks_idle_pending (bookmarks))
+        return;
+
+    g_idle_add (midori_bookmarks_idle_func, bookmarks);
+}
+
 static void
 midori_bookmarks_add_item (KatzeItem*       item,
                            MidoriBookmarks* bookmarks);
+
 static void
 midori_bookmarks_add_item_cb (KatzeArray*      array,
                               KatzeItem*       item,
                               MidoriBookmarks* bookmarks)
 {
-    midori_bookmarks_add_item (item, bookmarks);
+    midori_bookmarks_idle_start (bookmarks);
+
+    g_object_ref (item);
+    bookmarks->pending_inserts = g_list_append (bookmarks->pending_inserts, item);
 }
 
-
 static void
 midori_bookmarks_add_item (KatzeItem*       item,
                            MidoriBookmarks* bookmarks)
@@ -370,18 +635,16 @@
     GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
     GtkTreeIter iter;
 
-    if (!parentid)
-    {
-        midori_bookmarks_add_item_to_model (GTK_TREE_STORE (model), NULL, item);
-    }
+    if (parentid == katze_item_get_meta_integer (KATZE_ITEM (bookmarks->bookmarks_db), "id"))
+        midori_bookmarks_add_item_to_model (bookmarks, model, NULL, item);
     else if (midori_bookmarks_reach_item (model, &iter, parentid))
     {
         GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
+        gint n_children = gtk_tree_model_iter_n_children (model, &iter);
 
-        if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
-        {
-            midori_bookmarks_add_item_to_model (GTK_TREE_STORE (model), &iter, item);
-        }
+        if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path)
+            || !n_children)
+            midori_bookmarks_add_item_to_model (bookmarks, model, &iter, item);
 
         gtk_tree_path_free (path);
     }
@@ -389,8 +652,8 @@
 
 static void
 midori_bookmarks_update_item_cb (KatzeArray*      array,
-				 KatzeItem*       item,
-				 MidoriBookmarks* bookmarks)
+                                 KatzeItem*       item,
+                                 MidoriBookmarks* bookmarks)
 {
     gint64 id = katze_item_get_meta_integer (item, "id");
     gint64 parentid = katze_item_get_meta_integer (item, "parentid");
@@ -433,7 +696,7 @@
                 midori_bookmarks_add_item (item, bookmarks);
             }
         }
-        else if (parentid == 0)
+        else if (parentid == katze_item_get_meta_integer (KATZE_ITEM (bookmarks->bookmarks_db), "id"))
         {
             midori_bookmarks_update_item_in_model (bookmarks, GTK_TREE_STORE (model), &iter, item);
         }
@@ -457,6 +720,10 @@
     GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
     GtkTreeIter iter;
 
+    g_assert (KATZE_IS_ITEM (item));
+
+    midori_bookmarks_idle_remove_item (bookmarks, item);
+
     if (midori_bookmarks_reach_item (model, &iter, id))
     {
         GtkTreeIter parent;
@@ -486,12 +753,869 @@
 midori_bookmarks_update_cb (KatzeArray*      array,
                             MidoriBookmarks* bookmarks)
 {
+#if 1
+    g_print ("midori_bookmarks_update_cb: ignored ********\n");
+#else
     GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
+
     gtk_tree_store_clear (GTK_TREE_STORE (model));
     midori_bookmarks_read_from_db_to_model (bookmarks,
         GTK_TREE_STORE (model), NULL, 0, bookmarks->filter);
-}
-
+#endif
+}
+
+gboolean
+midori_bookmarks_tree_set_row_drag_data (GtkSelectionData *selection_data,
+                                         GtkTreeModel     *tree_model,
+                                         GList*           rows)
+{
+    TreeRowData *trd;
+    gint len;
+    gint struct_size;
+    gint length;
+    gint i;
+    GString *data;
+
+    g_return_val_if_fail (selection_data != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
+    g_return_val_if_fail (rows != NULL, FALSE);
+
+    data = g_string_new("");
+
+    length = g_list_length (rows);
+    for (i = 0; i < length; i++)
+    {
+        GtkTreePath *path = (GtkTreePath *)g_list_nth_data (rows, i);
+        gchar *path_str = gtk_tree_path_to_string (path);
+
+        g_string_append (data, path_str);
+        if (i < length-1)
+            g_string_append_c (data, '\n');
+    }
+
+    len = data->len;
+
+    /* the old allocate-end-of-struct-to-hold-string trick */
+    struct_size = sizeof (TreeRowData) + len + 1 -
+     (sizeof (TreeRowData) - G_STRUCT_OFFSET (TreeRowData, path));
+
+    trd = g_malloc (struct_size);
+
+    strcpy (trd->path, data->str);
+
+    g_string_free (data, TRUE);
+
+    trd->model = tree_model;
+
+    gtk_selection_data_set (selection_data,
+        gdk_atom_intern_static_string (MIDORI_BOOKMARKS_TREE_MODEL_TARGET),
+        8, /* bytes */
+        (void*)trd,
+        struct_size);
+
+    g_free (trd);
+
+    return TRUE;
+}
+
+static gboolean
+midori_bookmarks_tree_store_drag_data_get (GtkTreeDragSource*  drag_source,
+                                           GtkTreePath*      source_path,
+                                           GtkSelectionData* selection_data)
+{
+    MidoriBookmarksTreeStore *tree_store;
+    gboolean status = FALSE;
+
+    g_return_val_if_fail (selection_data != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_TREE_MODEL (drag_source), FALSE);
+    g_return_val_if_fail (source_path != NULL, FALSE);
+
+    tree_store = MIDORI_BOOKMARKS_TREE_STORE(drag_source);
+
+    if (tree_store->stock_got_rows)
+    {
+        g_list_free_full (tree_store->stock_got_rows, (GDestroyNotify) gtk_tree_path_free);
+        tree_store->stock_got_rows = NULL;
+    }
+
+    if (gtk_selection_data_get_target (selection_data) ==
+        gdk_atom_intern_static_string (MIDORI_BOOKMARKS_TREE_MODEL_TARGET))
+    {
+        GtkTreeModel *model;
+        GList* rows;
+        if (katze_tree_view_get_selected_rows (
+                tree_store->_view, &model, &rows))
+        {
+            status = midori_bookmarks_tree_set_row_drag_data (selection_data, model, rows);
+
+            tree_store->stock_got_rows = rows;
+        }
+    }
+
+    return status;
+}
+
+static void
+update_path_list_for_insert (GList * rows, GtkTreePath* path)
+{
+    gint length = g_list_length (rows);
+    gint i;
+
+    for (i = 0; i < length; i++ )
+    {
+        GtkTreePath *src_path_r = (GtkTreePath *)g_list_nth_data (rows, i);
+        gint la = gtk_tree_path_get_depth (path);
+        gint lb = gtk_tree_path_get_depth (src_path_r);
+        gint *ia = gtk_tree_path_get_indices (path);
+        gint *ib = gtk_tree_path_get_indices (src_path_r);
+        gint j;
+
+        if (la > lb)  /* insert was donne in a deeper branch than source */
+            continue;
+
+        if (ia[la-1] > ib[la-1]) /* insert was donne after source */
+            continue;
+
+        for (j = 0; j < la; j++)
+        {
+            if (ia[j] != ib[j]) break;
+        }
+
+        if (j < la-1) /* insert and source are not in the same branch */
+            continue;
+
+        /* source at depth level of insert must be incremented due to the insert */
+        ib[la-1] += 1;
+    }
+}
+
+static gint
+midori_tree_path_compare (const GtkTreePath *a,
+                          const GtkTreePath *b)
+{
+    if (!gtk_tree_path_get_depth ((GtkTreePath *)a))
+    {
+        if (!gtk_tree_path_get_depth ((GtkTreePath *)b))
+            return 0;
+
+        return -1;
+    }
+
+    if (!gtk_tree_path_get_depth ((GtkTreePath *)b))
+        return 1;
+
+    return gtk_tree_path_compare (a, b);
+}
+
+static GList*
+update_path_list_for_delete (GList* rows, GtkTreePath* removed_path)
+{
+    GList* new_rows = rows;
+
+    while (rows)
+    {
+        GtkTreePath *source_path = (GtkTreePath *)rows->data;
+        gint la = gtk_tree_path_get_depth (removed_path);
+        gint lb = gtk_tree_path_get_depth (source_path);
+        gint *ia = gtk_tree_path_get_indices (removed_path);
+        gint *ib = gtk_tree_path_get_indices (source_path);
+        gint cmp = midori_tree_path_compare (removed_path, source_path);
+        gint j;
+
+        if (cmp == 1) /* removal was done after source => kip source as it is */
+            goto keep_source;
+
+        if (cmp == 0) /* source is removed => remove source */
+            goto remove_source;
+
+        /* if removal is an ancestor of the source => remove source */
+        if (gtk_tree_path_is_ancestor (removed_path, source_path))
+            goto remove_source;
+
+        if (la > lb)  /* removal was donne in a deeper branch than source */
+            goto keep_source;
+
+        for (j = 0; j < la; j++)
+        {
+            if (ia[j] != ib[j]) break;
+        }
+
+        if (j < la-1) /* removal and source are not in the same branch */
+            goto keep_source;
+
+        /* source at depth level of removal must be decremented due to the removal */
+        ib[la-1] -= 1;
+
+        if (ib[la-1] >= 0)
+            goto keep_source;
+
+      remove_source:
+        /* remove source entry */
+        gtk_tree_path_free (source_path);
+        {
+            GList *next_rows = g_list_next (rows);
+            new_rows = g_list_delete_link (new_rows, rows);
+            rows = next_rows;
+        }
+        continue;
+
+      keep_source:
+        rows = g_list_next (rows);
+    }
+
+    return new_rows;
+}
+
+static gboolean
+midori_bookmarks_tree_store_drag_data_delete (GtkTreeDragSource*  drag_source,
+                                              GtkTreePath*      source_path)
+{
+    gboolean status = TRUE;
+    MidoriBookmarksTreeStore *tree_store = MIDORI_BOOKMARKS_TREE_STORE(drag_source);
+    GtkTreeModel* model = GTK_TREE_MODEL(drag_source);
+
+    if (!tree_store->stock_got_rows)
+        return TRUE;
+
+    while (tree_store->stock_got_rows)
+    {
+        GtkTreePath *prev = (GtkTreePath *)tree_store->stock_got_rows->data;
+        GtkTreeIter iter;
+
+        tree_store->stock_got_rows = g_list_delete_link (tree_store->stock_got_rows,
+            tree_store->stock_got_rows);
+
+        if (gtk_tree_model_get_iter (model, &iter, prev))
+        {
+            /* remove item updating source paths */
+            gtk_tree_store_remove (GTK_TREE_STORE (drag_source), &iter);
+
+            tree_store->stock_got_rows = update_path_list_for_delete (tree_store->stock_got_rows, prev);
+        }
+        else
+            status = FALSE;
+
+        gtk_tree_path_free (prev);
+    }
+
+    return status;
+}
+
+static gboolean
+midori_bookmarks_tree_store_get_rows_drag_data (GtkSelectionData  *selection_data,
+                                                GtkTreeModel     **tree_model,
+                                                GList     **rows)
+{
+    TreeRowData *trd;
+
+    g_return_val_if_fail (selection_data != NULL, FALSE);
+
+    if (tree_model)
+        *tree_model = NULL;
+
+    if (rows)
+        *rows = NULL;
+
+    if (gtk_selection_data_get_target (selection_data) !=
+        gdk_atom_intern_static_string (MIDORI_BOOKMARKS_TREE_MODEL_TARGET))
+        return FALSE;
+
+    if (gtk_selection_data_get_length (selection_data) < 0)
+        return FALSE;
+
+    trd = (void*) gtk_selection_data_get_data (selection_data);
+
+    if (tree_model)
+        *tree_model = trd->model;
+
+    if (rows)
+    {
+        GList *list = NULL;
+        gchar *trd_path = g_strdup (trd->path);
+        gchar *path_str;
+
+        path_str = strtok(trd_path, "\n");
+        while (path_str && *path_str)
+        {
+            list = g_list_append (list, gtk_tree_path_new_from_string (path_str));
+            path_str = strtok (NULL, "\n");
+        }
+
+        *rows = list;
+        g_free (trd_path);
+    }
+
+    return TRUE;
+}
+
+#if !GTK_CHECK_VERSION (3,0,0)
+gboolean
+gtk_tree_model_iter_previous (GtkTreeModel *tree_model,
+                              GtkTreeIter *iter)
+{
+    GtkTreePath* path = gtk_tree_model_get_path (tree_model, iter);
+    gboolean result = gtk_tree_path_prev (path);
+
+    if (result)
+        result = gtk_tree_model_get_iter (tree_model, iter, path);
+    else
+    {
+        GtkTreeIter invalid = {0};
+        *iter = invalid;
+    }
+
+    gtk_tree_path_free (path);
+    return result;
+}
+#endif
+
+static gboolean
+midori_bookmarks_tree_store_row_drop_possible (GtkTreeDragDest*  drag_dest,
+                                               GtkTreePath*      dest_path,
+                                               GtkSelectionData* selection_data)
+{
+    GtkTreeModel* dest_model = GTK_TREE_MODEL(drag_dest);
+    GtkTreePath *parent;
+    GtkTreeIter dest_parent;
+    GtkTreeIter *dest_parent_p = NULL;
+    gboolean row_drop_possible = TRUE;
+    GtkTreeViewDropPosition drop_position;
+
+    gtk_tree_view_get_drag_dest_row (MIDORI_BOOKMARKS_TREE_STORE (dest_model)->_view,
+        NULL, &drop_position);
+
+    parent = gtk_tree_path_copy (dest_path);
+    if ((gtk_tree_path_get_depth (parent) > 1)
+        && gtk_tree_path_up (parent)
+        && gtk_tree_model_get_iter (dest_model, &dest_parent, parent))
+        dest_parent_p = &dest_parent;
+
+    gtk_tree_path_free (parent);
+
+    if (dest_parent_p)
+    {
+        KatzeItem* item;
+
+        gtk_tree_model_get (dest_model, dest_parent_p, 0, &item, -1);
+
+        if (!KATZE_ITEM_IS_FOLDER (item))
+        {
+#ifdef DEBUG_DROP
+            gchar *dest_path_str = gtk_tree_path_to_string (dest_path);
+
+            g_print ("%s: can only drop into folders\n", dest_path_str);
+            g_free (dest_path_str);
+#endif /* DEBUG_DROP */
+            row_drop_possible = FALSE;
+        }
+
+        if (item)
+            g_object_unref (item);
+    }
+
+    if (row_drop_possible
+        && (gtk_selection_data_get_target (selection_data) ==
+            gdk_atom_intern_static_string (MIDORI_BOOKMARKS_TREE_MODEL_TARGET)))
+    {
+        GtkTreeModel *src_model;
+        GList* rows;
+
+        if (midori_bookmarks_tree_store_get_rows_drag_data (selection_data,
+                &src_model, &rows))
+        {
+            GtkTreeIter dest_iter;
+            GList* src_row;
+            gboolean dest_is_folder = FALSE;
+            /* gboolean dest_is_bookmark = FALSE; */
+            gboolean src_has_folders = FALSE;
+            gboolean src_has_bookmarks = FALSE;
+
+            if (gtk_tree_model_get_iter (dest_model, &dest_iter, dest_path))
+            {
+                if (gtk_tree_model_iter_has_child (dest_model, &dest_iter))
+                    dest_is_folder = TRUE;
+/*
+                else
+                {
+                    KatzeItem* item;
+                    gtk_tree_model_get (dest_model, &dest_iter, 0, &item, -1);
+                    if (item)
+                    {
+                        dest_is_bookmark = TRUE;
+                        g_object_unref (item);
+                    }
+                }
+*/
+            }
+
+            for (src_row = rows ; src_row ; src_row = g_list_next (src_row))
+            {
+                GtkTreePath* src_path = (GtkTreePath*)src_row->data;
+                GtkTreeIter src_iter;
+                KatzeItem* item;
+
+                if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path))
+                    continue;
+
+                gtk_tree_model_get (src_model, &src_iter, 0, &item, -1);
+                if (item)
+                {
+                    if (!src_has_folders && KATZE_ITEM_IS_FOLDER (item))
+                        src_has_folders = TRUE;
+                    else if (!src_has_bookmarks && KATZE_ITEM_IS_BOOKMARK (item))
+                        src_has_bookmarks = TRUE;
+
+                    g_object_unref (item);
+                }
+                if (src_has_bookmarks && src_has_folders)
+                    break;
+            }
+
+            if (src_has_bookmarks)
+            {
+                switch (drop_position)
+                {
+                    case GTK_TREE_VIEW_DROP_BEFORE:
+                    case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
+                        if (dest_is_folder)
+                        {
+#ifdef DEBUG_DROP
+                            gchar *dest_path_str = gtk_tree_path_to_string (dest_path);
+
+                            g_print ("%s: cannot drop bookmarks in folders group\n", dest_path_str);
+                            g_free (dest_path_str);
+#endif /* DEBUG_DROP */
+                            row_drop_possible = FALSE;
+                            goto done;
+                        }
+                        break;
+                    case GTK_TREE_VIEW_DROP_AFTER:
+                    case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
+                        if (dest_is_folder)
+                        {
+                            gboolean next_dest_is_folder = FALSE;
+
+                            if (gtk_tree_model_iter_next (dest_model, &dest_iter))
+                                if (gtk_tree_model_iter_has_child (dest_model, &dest_iter))
+                                    next_dest_is_folder = TRUE;
+
+                            if (next_dest_is_folder)
+                            {
+#ifdef DEBUG_DROP
+                                gchar *dest_path_str = gtk_tree_path_to_string (dest_path);
+
+                                g_print ("%s: cannot drop bookmarks in folders group\n", dest_path_str);
+                                g_free (dest_path_str);
+#endif /* DEBUG_DROP */
+                                row_drop_possible = FALSE;
+                                goto done;
+                            }
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+            else if (src_has_folders)
+            {
+                gboolean prev_dest_is_folder = TRUE;
+
+                if (gtk_tree_model_iter_previous (dest_model, &dest_iter))
+                    if (!gtk_tree_model_iter_has_child (dest_model, &dest_iter))
+                        prev_dest_is_folder = FALSE;
+
+                if (!prev_dest_is_folder)
+                {
+#ifdef DEBUG_DROP
+                    gchar *dest_path_str = gtk_tree_path_to_string (dest_path);
+
+                    g_print ("%s: cannot drop folders in bookmarks group\n", dest_path_str);
+                    g_free (dest_path_str);
+#endif /* DEBUG_DROP */
+                    row_drop_possible = FALSE;
+                    goto done;
+                }
+            }
+
+            if (src_model == dest_model)
+            {
+                for (src_row = rows ; src_row ; src_row = g_list_next (src_row))
+                {
+                    GtkTreePath* src_path = (GtkTreePath*)src_row->data;
+
+                    /* Can't drop into ourself. */
+                    if (gtk_tree_path_is_ancestor (src_path, dest_path))
+                    {
+#ifdef DEBUG_DROP
+                        g_print ("cannot drop into source folders\n");
+#endif /* DEBUG_DROP */
+                        row_drop_possible = FALSE;
+                        goto done;
+                    }
+                    update_path_list_for_insert (rows, dest_path);
+                }
+            }
+          done:
+            g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+        }
+        else
+            row_drop_possible = FALSE;
+    }
+    else
+        row_drop_possible = FALSE;
+
+#ifdef DEBUG_DROP
+    if (row_drop_possible)
+    {
+        gchar *dest_path_str = gtk_tree_path_to_string (dest_path);
+        gchar *drop_position_str = "unknown";
+        switch (drop_position)
+        {
+            case GTK_TREE_VIEW_DROP_BEFORE:
+                drop_position_str = "before";
+                break;
+            case GTK_TREE_VIEW_DROP_AFTER:
+                drop_position_str = "after";
+                break;
+            case  GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
+                drop_position_str = "into or before";
+                break;
+            case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
+                drop_position_str = "into or after";
+                break;
+        }
+
+        g_print ("%s: row drop possible (%s)\n", dest_path_str, drop_position_str);
+        g_free (dest_path_str);
+    }
+#endif /* DEBUG_DROP */
+
+    return row_drop_possible;
+}
+
+static void
+copy_node_data (GtkTreeStore *src_store,
+                GtkTreeIter  *src_iter,
+                GtkTreeStore *dest_store,
+                GtkTreeIter  *dest_iter)
+{
+    gint i;
+    gint n_columns;
+    GtkTreeModel* src_model = GTK_TREE_MODEL (src_store);
+
+    n_columns = gtk_tree_model_get_n_columns (src_model);
+
+    for (i = 0; i < n_columns; i++)
+    {
+        void *item;
+
+        gtk_tree_model_get (src_model, src_iter, i, &item, -1);
+        gtk_tree_store_set (dest_store, dest_iter, i, item, -1);
+    }
+}
+
+static void
+recursive_node_copy (GtkTreeStore *src_store,
+                     GtkTreeIter  *src_iter,
+                     GtkTreeStore *dest_store,
+                     GtkTreeIter  *dest_iter)
+{
+    GtkTreeIter child;
+    GtkTreeModel *src_model = GTK_TREE_MODEL (src_store);
+
+    copy_node_data (src_store, src_iter, dest_store, dest_iter);
+
+    if (gtk_tree_model_iter_children (src_model, &child, src_iter))
+    {
+        /* Need to create children and recurse. Note our
+         * dependence on persistent iterators here.
+         */
+        do
+        {
+            GtkTreeIter copy;
+
+            /* Gee, a really slow algorithm... ;-) FIXME */
+            gtk_tree_store_append (dest_store,
+                &copy,
+                dest_iter);
+
+            recursive_node_copy (src_store, &child, dest_store, &copy);
+        }
+        while (gtk_tree_model_iter_next (src_model, &child));
+    }
+}
+
+static gboolean
+midori_bookmarks_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
+                                                GtkTreePath       *dest_path,
+                                                GtkSelectionData  *selection_data)
+{
+    gboolean status = TRUE;
+
+    g_return_val_if_fail (selection_data != NULL, FALSE);
+    g_return_val_if_fail (GTK_IS_TREE_MODEL (drag_dest), FALSE);
+    g_return_val_if_fail (dest_path != NULL, FALSE);
+
+    if (gtk_selection_data_get_target (selection_data) ==
+        gdk_atom_intern_static_string (MIDORI_BOOKMARKS_TREE_MODEL_TARGET))
+    {
+        GtkTreeStore *dest_store = GTK_TREE_STORE (drag_dest);
+        GtkTreeModel *dest_model = GTK_TREE_MODEL (drag_dest);
+        GtkTreeModel *src_model;
+        GList* rows;
+
+        if (midori_bookmarks_tree_store_get_rows_drag_data (selection_data,
+                &src_model, &rows))
+        {
+            GtkTreeStore *src_store = GTK_TREE_STORE (src_model);
+            GtkTreePath *prev = gtk_tree_path_copy (dest_path);
+
+            gint count = 0;
+            gint length = g_list_length (rows);
+            gint i;
+
+            for (i = 0; i < length; i++)
+            {
+                GtkTreeIter dest_iter;
+                GtkTreeIter src_iter;
+                GtkTreePath *src_path = (GtkTreePath *)g_list_nth_data (rows, i);
+
+                if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path))
+                    continue;
+
+                /* Get the path to insert _after_ (dest is the path to insert _before_) */
+                if (i == 0)
+                {
+                    if (!gtk_tree_path_prev (prev))
+                    {                   /* Get the parent, NULL if parent is the root */
+                        GtkTreeIter dest_parent;
+                        GtkTreePath *parent = gtk_tree_path_copy (dest_path);
+                        GtkTreeIter *dest_parent_p = NULL;
+
+                        if (gtk_tree_path_up (parent) &&
+                            gtk_tree_path_get_depth (parent) > 0)
+                        {
+                            gtk_tree_model_get_iter (dest_model,
+                                &dest_parent, parent);
+                            dest_parent_p = &dest_parent;
+                        }
+                        gtk_tree_path_free (parent);
+
+                        gtk_tree_store_prepend (dest_store, &dest_iter, dest_parent_p);
+                    }
+                    else if (gtk_tree_model_get_iter (dest_model, &dest_iter, prev))
+                    {
+                        GtkTreeIter tmp_iter = dest_iter;
+
+                        gtk_tree_store_insert_after (dest_store, &dest_iter, NULL,
+                            &tmp_iter);
+                    }
+                }
+                else if (gtk_tree_model_get_iter (dest_model, &dest_iter, prev))
+                {
+                    GtkTreeIter tmp_iter = dest_iter;
+
+                    gtk_tree_store_insert_after (dest_store, &dest_iter, NULL,
+                        &tmp_iter);
+                }
+
+                gtk_tree_path_free (prev);
+
+                recursive_node_copy (src_store, &src_iter,  dest_store, &dest_iter);
+                count++;
+
+                prev = gtk_tree_model_get_path (dest_model, &dest_iter);
+
+                if (src_store != dest_store)
+                    continue;
+
+                update_path_list_for_insert (rows, prev);
+            }
+
+            gtk_tree_path_free (prev);
+
+            g_assert (count == length);
+
+            if (src_store == dest_store)
+            {
+                MidoriBookmarksTreeStore *tree_store = MIDORI_BOOKMARKS_TREE_STORE(src_store);
+
+                g_list_free_full (tree_store->stock_got_rows, (GDestroyNotify) gtk_tree_path_free);
+                tree_store->stock_got_rows = rows;
+            }
+            else
+                g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+        }
+    }
+
+    return status;
+}
+
+static void
+midori_bookmarks_set_item_positon (GtkTreeModel*    model,
+				                   GtkTreeIter*     iter,
+				                   gint64           parentid,
+				                   MidoriBookmarks* bookmarks)
+{
+    KatzeItem* item;
+    gint position = 0;
+    GtkTreeIter next = *iter;
+
+    do {
+        gboolean update = FALSE;
+        gtk_tree_model_get (model, &next, 0, &item, -1);
+
+        if (!KATZE_IS_ITEM (item))
+            continue;
+
+        if (position != katze_item_get_meta_integer (item, "pos_panel"))
+        {
+            katze_item_set_meta_integer (item, "pos_panel", position);
+            update = TRUE;
+        }
+        if (parentid != katze_item_get_meta_integer (item, "parentid"))
+        {
+            katze_item_set_meta_integer (item, "parentid", parentid);
+            update = TRUE;
+        }
+
+        if (update)
+            midori_bookmarks_update_item (bookmarks, item);
+
+        position++;
+
+        g_object_unref (item);
+    }
+    while (gtk_tree_model_iter_next (model, &next));
+}
+
+static void
+assert_reorder_are_folders (GtkTreeModel*    model,
+			                MidoriBookmarks* bookmarks)
+{
+    GList* iter;
+    for (iter = bookmarks->reordered_paths; iter ; iter = g_list_next (iter))
+    {
+       GtkTreePath* path = (GtkTreePath*)iter->data;
+       GtkTreeIter tree_iter;
+
+       if (!gtk_tree_path_get_depth (path))
+           continue;
+
+       if (gtk_tree_model_get_iter (model, &tree_iter, path))
+       {
+           KatzeItem *item;
+
+           gtk_tree_model_get (model, &tree_iter, 0, &item, -1);
+
+           g_assert (KATZE_ITEM_IS_FOLDER (item));
+       }
+    }
+}
+
+static void
+add_parent_to_reorder (GtkTreeModel*    model,
+			           GtkTreePath*     path,
+			           MidoriBookmarks* bookmarks)
+{
+    GtkTreePath* path_copy = gtk_tree_path_copy (path);
+    GList* found;
+
+    midori_bookmarks_idle_start (bookmarks);
+
+    if (gtk_tree_path_get_depth (path_copy) > 1
+        && gtk_tree_path_up (path_copy))
+    {
+        GtkTreeIter iter;
+        if (gtk_tree_model_get_iter (model, &iter, path_copy))
+        {
+            KatzeItem* item;
+            gtk_tree_model_get (model, &iter, 0, &item, -1);
+            if (item)
+            {
+                g_assert (KATZE_ITEM_IS_FOLDER (item));
+                g_object_unref (item);
+            }
+            else
+                g_assert_not_reached ();
+        }
+        else
+            g_assert_not_reached ();
+    }
+    else
+    {
+        gtk_tree_path_free (path_copy);
+        path_copy = gtk_tree_path_new ();
+    }
+
+    if ((found = g_list_find_custom (bookmarks->reordered_paths,
+                path_copy, (GCompareFunc)midori_tree_path_compare)) != NULL)
+    {
+        gtk_tree_path_free (path_copy);
+        return;
+    }
+
+    bookmarks->reordered_paths = g_list_append (bookmarks->reordered_paths, path_copy);
+}
+
+static void
+midori_bookmarks_row_inserted_cb (GtkTreeModel*    model,
+			                      GtkTreePath*     path,
+			                      GtkTreeIter*     iter,
+			                      MidoriBookmarks* bookmarks)
+{
+    midori_bookmarks_idle_start (bookmarks);
+
+    update_path_list_for_insert (bookmarks->added_paths, path);
+    update_path_list_for_insert (bookmarks->reordered_paths, path);
+    assert_reorder_are_folders (model, bookmarks);
+
+    if (g_list_find_custom (bookmarks->added_paths,
+        path, (GCompareFunc)midori_tree_path_compare))
+        return;
+
+    bookmarks->added_paths = g_list_append (bookmarks->added_paths, gtk_tree_path_copy (path));
+}
+
+#ifdef DEBUG_LIST
+static void
+print_path_list (GList* iter)
+{
+    for ( ; iter ; iter = g_list_next (iter))
+    {
+        gchar* str = gtk_tree_path_to_string ((GtkTreePath*)iter->data);
+        g_print ("%s ", str);
+        g_free (str);
+    }
+    g_print ("\n");
+}
+#endif /* DEBUG_LIST */
+
+static void
+midori_bookmarks_row_deleted_cb (GtkTreeModel*    model,
+				                 GtkTreePath*     path,
+				                 MidoriBookmarks* bookmarks)
+{
+#ifdef DEBUG_LIST
+    gchar* str = gtk_tree_path_to_string (path);
+    g_print ("midori_bookmarks_row_deleted_cb: path: %s\n", str);
+    g_free (str);
+#endif /* DEBUG_LIST */
+
+    midori_bookmarks_idle_start (bookmarks);
+
+    bookmarks->added_paths = update_path_list_for_delete (bookmarks->added_paths, path);
+#ifdef DEBUG_LIST
+    print_path_list (bookmarks->reordered_paths);
+#endif /* DEBUG_LIST */
+    bookmarks->reordered_paths = update_path_list_for_delete (bookmarks->reordered_paths, path);
+#ifdef DEBUG_LIST
+    print_path_list (bookmarks->reordered_paths);
+#endif /* DEBUG_LIST */
+    assert_reorder_are_folders (model, bookmarks);
+    add_parent_to_reorder (model, path, bookmarks);
+    assert_reorder_are_folders (model, bookmarks);
+}
 
 static void
 midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
@@ -499,41 +1623,8 @@
                                  GtkTreeIter*     iter,
                                  MidoriBookmarks* bookmarks)
 {
-    KatzeItem* item;
-    GtkTreeIter parent;
-    KatzeItem* new_parent = NULL;
-    gint64 parentid;
-
-    gtk_tree_model_get (model, iter, 0, &item, -1);
-
-    if (gtk_tree_model_iter_parent (model, &parent, iter))
-    {
-        gtk_tree_model_get (model, &parent, 0, &new_parent, -1);
-
-        /* Bookmarks must not be moved into non-folder items */
-        if (!KATZE_ITEM_IS_FOLDER (new_parent))
-            parentid = 0;
-        else
-            parentid = katze_item_get_meta_integer (new_parent, "id");
-    }
-    else
-        parentid = 0;
-
-    katze_item_set_meta_integer (item, "parentid", parentid);
-
-    g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
-        midori_bookmarks_update_item_cb,
-        bookmarks);
-
-    midori_bookmarks_db_update_item (bookmarks->bookmarks_db, item);
-
-    g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
-        midori_bookmarks_update_item_cb,
-        bookmarks);
-
-    g_object_unref (item);
-    if (new_parent)
-        g_object_unref (new_parent);
+    add_parent_to_reorder (model, path, bookmarks);
+    assert_reorder_are_folders (model, bookmarks);
 }
 
 static void
@@ -596,7 +1687,7 @@
     GtkTreeIter iter;
 
     if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (bookmarks->treeview),
-                                           &model, &iter))
+            &model, &iter))
     {
         KatzeItem* item;
         MidoriBrowser* browser;
@@ -616,15 +1707,17 @@
 static void
 midori_bookmarks_toolbar_update (MidoriBookmarks *bookmarks)
 {
-    gboolean selected;
+    gint selected;
 
-    selected = katze_tree_view_get_selected_iter (
+    selected = katze_tree_view_get_selected_rows (
         GTK_TREE_VIEW (bookmarks->treeview), NULL, NULL);
-    gtk_widget_set_sensitive (GTK_WIDGET (bookmarks->delete), selected);
-    gtk_widget_set_sensitive (GTK_WIDGET (bookmarks->edit), selected);
+    gtk_widget_set_sensitive (
+        GTK_WIDGET (bookmarks->delete), (selected > 0 ? TRUE : FALSE));
+    gtk_widget_set_sensitive (
+        GTK_WIDGET (bookmarks->edit), (selected == 1 ? TRUE : FALSE));
 }
 
-static gchar* 
+static gchar*
 midori_bookmarks_statusbar_bookmarks_str (gint count)
 {
     if (!count)
@@ -634,7 +1727,7 @@
     return g_strdup_printf (ngettext ("%d bookmark", "%d bookmarks", count), count);
 }
 
-static gchar* 
+static gchar*
 midori_bookmarks_statusbar_subfolders_str (gint count)
 {
     if (!count)
@@ -648,78 +1741,141 @@
 midori_bookmarks_statusbar_update (MidoriBookmarks *bookmarks)
 {
     gchar* text = NULL;
-
-    if (bookmarks->hovering_item)
-    {
-        KatzeItem* item = bookmarks->hovering_item;
-
-        g_assert (!KATZE_ITEM_IS_SEPARATOR (item));
-
-        if (KATZE_ITEM_IS_FOLDER (item))
+    GtkTreeModel* model;
+    GList   *rows;
+    gint selected;
+
+    selected = katze_tree_view_get_selected_rows (
+        GTK_TREE_VIEW (bookmarks->treeview), &model, &rows);
+
+    if (selected > 1)
+    {
+        gint i;
+        gint selected_folders_count = 0;
+        gint selected_bookmarks_count = 0;
+        gchar* selected_folders_str = midori_bookmarks_statusbar_subfolders_str (selected_folders_count);
+        gchar* selected_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (selected_bookmarks_count);
+
+        for (i = 0 ; i < selected ; i++)
+        {
+            GtkTreeIter iter;
+            KatzeItem* item;
+
+            if (!gtk_tree_model_get_iter (
+                    model, &iter, (GtkTreePath *)g_list_nth_data (rows, i)))
+                continue;
+
+            gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+            g_assert (!KATZE_ITEM_IS_SEPARATOR (item));
+
+            if (KATZE_ITEM_IS_FOLDER (item))
+            {
+                selected_folders_count++;
+            }
+            else
+            {
+                selected_bookmarks_count++;
+            }
+        }
+
+        selected_folders_str = midori_bookmarks_statusbar_subfolders_str (selected_folders_count);
+        selected_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (selected_bookmarks_count);
+
+        if (!selected_bookmarks_count && !selected_folders_count)
+            g_assert_not_reached ();
+        else if (!selected_bookmarks_count && (selected_folders_count >= 1))
+            /* i18n: Selection containing [[n] folder(s)] and no bookmark */
+            text = g_strdup_printf (_("Selection containing %s and no bookmark"),
+                selected_folders_str);
+        else if ((selected_bookmarks_count >= 1) && !selected_folders_count)
+            /* i18n: Selection containing [[n] bookmark(s)] */
+            text = g_strdup_printf (_("Selection containing %s"), selected_bookmarks_str);
+        else if ((selected_bookmarks_count >= 1) && (selected_folders_count >= 1))
+            /* i18n: Selection containing [[n] bookmark(s)] and [[n] folder(s)] */
+            text = g_strdup_printf (_("Selection containing %s and %s"),
+                selected_bookmarks_str, selected_folders_str);
+
+        g_free (selected_folders_str);
+        g_free (selected_bookmarks_str);
+
+        g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+    }
+    else
+    {
+        if (selected)
+            g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+
+        if (bookmarks->hovering_item)
+        {
+            KatzeItem* item = bookmarks->hovering_item;
+
+            if (KATZE_ITEM_IS_FOLDER (item))
+            {
+                gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
+                    "uri = ''", NULL, item, FALSE);
+                gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
+                    "uri <> ''", NULL, item, FALSE);
+                gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
+                gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
+
+                if (!child_bookmarks_count && !child_folders_count)
+                    /* i18n: Empty folder */
+                    text = g_strdup_printf (_("Empty folder"));
+                else if (!child_bookmarks_count && (child_folders_count >= 1))
+                    /* i18n: Folder containing [[n] folder(s)] and no bookmark */
+                    text = g_strdup_printf (_("Folder containing %s and no bookmark"),
+                        child_folders_str);
+                else if ((child_bookmarks_count >= 1) && !child_folders_count)
+                    /* i18n: Folder containing [[n] bookmark(s)] */
+                    text = g_strdup_printf (_("Folder containing %s"), child_bookmarks_str);
+                else if ((child_bookmarks_count >= 1) && (child_folders_count >= 1))
+                    /* i18n: Folder containing [[n] bookmark(s)] and [[n] folder(s)] */
+                    text = g_strdup_printf (_("Folder containing %s and %s"),
+                        child_bookmarks_str, child_folders_str);
+
+                g_free (child_folders_str);
+                g_free (child_bookmarks_str);
+            }
+            else if (KATZE_ITEM_IS_BOOKMARK (item))
+            {
+                const gchar* uri = katze_item_get_uri (item);
+
+                /* i18n: Bookmark leading to: [bookmark uri] */
+                text = g_strdup_printf (_("Bookmark leading to: %s"), uri);
+            }
+        }
+        else
         {
             gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
-                "uri = ''", NULL, item, FALSE);
+                "uri = ''", NULL, NULL, FALSE);
             gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
-                "uri <> ''", NULL, item, FALSE);
+                "uri <> ''", NULL, NULL, FALSE);
             gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
             gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
 
-            if (!child_bookmarks_count && !child_folders_count)
-                /* i18n: Empty folder */
-                text = g_strdup_printf (_("Empty folder"));
-            else if (!child_bookmarks_count && (child_folders_count >= 1))
-                /* i18n: Folder containing [[n] folder(s)] and no bookmark */
-                text = g_strdup_printf (_("Folder containing %s and no bookmark"),
+            if (!child_bookmarks_count && (child_folders_count >= 1))
+                /* i18n: [[n] folder(s)] and no bookmark */
+                text = g_strdup_printf (_("%s and no bookmark"),
                     child_folders_str);
             else if ((child_bookmarks_count >= 1) && !child_folders_count)
-                /* i18n: Folder containing [[n] bookmark(s)] */
-               text = g_strdup_printf (_("Folder containing %s"), child_bookmarks_str);
+                text = g_strdup (child_bookmarks_str);
             else if ((child_bookmarks_count >= 1) && (child_folders_count >= 1))
-                /* i18n: Folder containing [[n] bookmark(s)] and [[n] folder(s)] */
-                text = g_strdup_printf (_("Folder containing %s and %s"),
+                /* i18n: [[n] bookmark(s)] and [[n] folder(s)] */
+                text = g_strdup_printf (_("%s and %s"),
                     child_bookmarks_str, child_folders_str);
 
             g_free (child_folders_str);
             g_free (child_bookmarks_str);
         }
-        else if (KATZE_ITEM_IS_BOOKMARK (item))
-        {
-            const gchar* uri = katze_item_get_uri (item);
-
-            /* i18n: Bookmark leading to: [bookmark uri] */
-            text = g_strdup_printf (_("Bookmark leading to: %s"), uri);
-        }
-    }
-    else
-    {
-        gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
-            "uri = ''", NULL, NULL, FALSE);
-        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
-            "uri <> ''", NULL, NULL, FALSE);
-        gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
-        gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
-        
-        if (!child_bookmarks_count && (child_folders_count >= 1))
-            /* i18n: [[n] folder(s)] and no bookmark */
-            text = g_strdup_printf (_("%s and no bookmark"),
-                child_folders_str);
-        else if ((child_bookmarks_count >= 1) && !child_folders_count)
-            text = g_strdup (child_bookmarks_str);
-        else if ((child_bookmarks_count >= 1) && (child_folders_count >= 1))
-            /* i18n: [[n] bookmark(s)] and [[n] folder(s)] */
-            text = g_strdup_printf (_("%s and %s"),
-                child_bookmarks_str, child_folders_str);
-        
-        g_free (child_folders_str);
-        g_free (child_bookmarks_str);
     }
 
     if (text)
     {
         MidoriBrowser* browser = midori_browser_get_for_widget (bookmarks->treeview);
-        
+
         g_object_set (browser, "statusbar-text", text, NULL);
-        
+
         g_free(text);
     }
 }
@@ -729,19 +1885,33 @@
                                     MidoriBookmarks* bookmarks)
 {
     GtkTreeModel* model;
-    GtkTreeIter iter;
-
-    if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (bookmarks->treeview),
-                                           &model, &iter))
+    GList* rows;
+    GList* iter_row;
+
+    if (!katze_tree_view_get_selected_rows(GTK_TREE_VIEW (bookmarks->treeview),
+            &model, &rows))
+        return;
+
+    for (iter_row = rows ; iter_row ; iter_row = g_list_next (iter_row))
     {
-        KatzeItem* item;
-
-        gtk_tree_model_get (model, &iter, 0, &item, -1);
-
-        midori_bookmarks_db_remove_item (bookmarks->bookmarks_db, item);
-
-        g_object_unref (item);
+        GtkTreeIter iter;
+
+        if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath *)iter_row->data))
+        {
+            KatzeItem* item;
+
+            gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+            if (item)
+            {
+                midori_bookmarks_db_remove_item (bookmarks->bookmarks_db, item);
+
+                g_object_unref (item);
+            }
+        }
     }
+
+    g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
 }
 
 static GtkWidget*
@@ -759,7 +1929,7 @@
         toolitem = gtk_tool_button_new_from_stock (STOCK_BOOKMARK_ADD);
         gtk_widget_set_name (GTK_WIDGET (toolitem), "BookmarkAdd");
         gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
-                                     _("Add a new bookmark"));
+            _("Add a new bookmark"));
         gtk_tool_item_set_is_important (toolitem, TRUE);
         g_signal_connect (toolitem, "clicked",
             G_CALLBACK (midori_bookmarks_add_clicked_cb), bookmarks);
@@ -767,7 +1937,7 @@
         gtk_widget_show (GTK_WIDGET (toolitem));
         toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_EDIT);
         gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
-                                     _("Edit the selected bookmark"));
+            _("Edit the selected bookmark"));
         g_signal_connect (toolitem, "clicked",
             G_CALLBACK (midori_bookmarks_edit_clicked_cb), bookmarks);
         gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
@@ -775,7 +1945,7 @@
         bookmarks->edit = GTK_WIDGET (toolitem);
         toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_DELETE);
         gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
-                                     _("Delete the selected bookmark"));
+            _("Delete the selected bookmark"));
         g_signal_connect (toolitem, "clicked",
             G_CALLBACK (midori_bookmarks_delete_clicked_cb), bookmarks);
         gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
@@ -791,7 +1961,7 @@
         toolitem = gtk_tool_button_new_from_stock (STOCK_FOLDER_NEW);
         gtk_widget_set_name (GTK_WIDGET (toolitem), "BookmarkFolderAdd");
         gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem),
-                                     _("Add a new folder"));
+            _("Add a new folder"));
         g_signal_connect (toolitem, "clicked",
             G_CALLBACK (midori_bookmarks_add_clicked_cb), bookmarks);
         gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
@@ -841,6 +2011,12 @@
                       G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
     g_signal_connect (bookmarks->bookmarks_db, "update",
                       G_CALLBACK (midori_bookmarks_update_cb), bookmarks);
+    g_signal_connect_after (model, "row-inserted",
+                            G_CALLBACK (midori_bookmarks_row_inserted_cb),
+                            bookmarks);
+    g_signal_connect_after (model, "row-deleted",
+                            G_CALLBACK (midori_bookmarks_row_deleted_cb),
+                            bookmarks);
     g_signal_connect_after (model, "row-changed",
                             G_CALLBACK (midori_bookmarks_row_changed_cb),
                             bookmarks);
@@ -856,12 +2032,12 @@
 
     switch (prop_id)
     {
-    case PROP_APP:
-        midori_bookmarks_set_app (bookmarks, g_value_get_object (value));
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
+        case PROP_APP:
+            midori_bookmarks_set_app (bookmarks, g_value_get_object (value));
+            break;
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            break;
     }
 }
 
@@ -875,12 +2051,12 @@
 
     switch (prop_id)
     {
-    case PROP_APP:
-        g_value_set_object (value, bookmarks->app);
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
+        case PROP_APP:
+            g_value_set_object (value, bookmarks->app);
+            break;
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            break;
     }
 }
 
@@ -918,8 +2094,8 @@
     if (item && katze_item_get_name (item))
     {
         g_object_set (renderer, "markup", NULL,
-                      "ellipsize", PANGO_ELLIPSIZE_END,
-                      "text", katze_item_get_name (item), NULL);
+            "ellipsize", PANGO_ELLIPSIZE_END,
+            "text", katze_item_get_name (item), NULL);
     }
     else
         g_object_set (renderer, "markup", _("<i>Separator</i>"), NULL);
@@ -976,7 +2152,7 @@
     menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
     if (label)
         gtk_label_set_text_with_mnemonic (GTK_LABEL (gtk_bin_get_child (
-        GTK_BIN (menuitem))), label);
+                    GTK_BIN (menuitem))), label);
     if (!strcmp (stock_id, GTK_STOCK_EDIT))
         gtk_widget_set_sensitive (menuitem,
             !KATZE_ITEM_IS_SEPARATOR (item));
@@ -1007,39 +2183,103 @@
     }
 }
 
-static void
-midori_bookmarks_open_in_tab_activate_cb (GtkWidget*       menuitem,
-                                          MidoriBookmarks* bookmarks)
-{
-    KatzeItem* item;
-    const gchar* uri;
-
-    item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
-    if (KATZE_ITEM_IS_FOLDER (item))
+static GtkWidget*
+midori_bookmarks_open_bookmark_in_tab (KatzeItem *item,
+						MidoriBrowser* browser)
+{
+    const gchar* uri = katze_item_get_uri (item);
+
+    if (!uri || !*uri)
+        return NULL;
+
+    return midori_browser_add_item (browser, item);
+}
+
+static GtkWidget*
+midori_bookmarks_open_folder_in_tab (gint64 parentid,
+				     MidoriBookmarks* bookmarks,
+				     MidoriBrowser* browser)
+{
+    GtkWidget* last_view = NULL;
+    KatzeArray* array;
+
+    array = midori_bookmarks_read_from_db (bookmarks, parentid, NULL);
+
+    if (KATZE_IS_ARRAY (array))
     {
         KatzeItem* child;
-        KatzeArray* array;
-
-        array = midori_bookmarks_read_from_db (bookmarks,
-                katze_item_get_meta_integer (item, "parentid"), NULL);
-
-        g_return_if_fail (KATZE_IS_ARRAY (array));
+
         KATZE_ARRAY_FOREACH_ITEM (child, array)
         {
-            if ((uri = katze_item_get_uri (child)) && *uri)
+            GtkWidget* view = midori_bookmarks_open_bookmark_in_tab (child, browser);
+            if (view)
+                last_view = view;
+        }
+    }
+
+    return last_view;
+}
+
+static void
+midori_bookmarks_open_in_tab_activate_cb (GtkWidget*       menuitem,
+                                          MidoriBookmarks* bookmarks)
+{
+    GtkWidget* last_view = NULL;
+    MidoriBrowser* browser = midori_browser_get_for_widget (GTK_WIDGET (bookmarks));
+    GtkTreeModel* model;
+    GList* rows;
+    gint length;
+
+    length = katze_tree_view_get_selected_rows (GTK_TREE_VIEW (bookmarks->treeview),
+        &model, &rows);
+
+    if (!length)
+    {
+        KatzeItem* root = KATZE_ITEM (bookmarks->bookmarks_db);
+        KatzeItem* item = KATZE_ITEM (g_object_get_data (G_OBJECT (menuitem), "KatzeItem"));
+
+        if (item != root)
+            return;
+
+        last_view = midori_bookmarks_open_folder_in_tab (0, bookmarks, browser);
+    }
+    else
+    {
+        gint i;
+
+        for (i = 0 ; i < length; i++)
+        {
+            GtkTreeIter iter;
+
+            if (gtk_tree_model_get_iter (
+                    model, &iter, (GtkTreePath *)g_list_nth_data (rows, i)))
             {
-                MidoriBrowser* browser = midori_browser_get_for_widget (GTK_WIDGET (bookmarks));
-                GtkWidget* view = midori_browser_add_item (browser, child);
-                midori_browser_set_current_tab_smartly (browser, view);
+                GtkWidget* view = NULL;
+                KatzeItem* item;
+
+                gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+                if (KATZE_ITEM_IS_SEPARATOR(item))
+                    continue;
+
+                if (KATZE_ITEM_IS_FOLDER (item))
+                    view = midori_bookmarks_open_folder_in_tab (
+                        katze_item_get_meta_integer (item, "id"), bookmarks, browser);
+                else
+                    view = midori_bookmarks_open_bookmark_in_tab (item, browser);
+
+                g_object_unref (item);
+
+                if (view)
+                    last_view = view;
             }
         }
-    }
-    else if ((uri = katze_item_get_uri (item)) && *uri)
-    {
-        MidoriBrowser* browser = midori_browser_get_for_widget (GTK_WIDGET (bookmarks));
-        GtkWidget* view = midori_browser_add_item (browser, item);
-        midori_browser_set_current_tab_smartly (browser, view);
-    }
+
+        g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+    }
+
+    if (last_view)
+        midori_browser_set_current_tab_smartly (browser, last_view);
 }
 
 static void
@@ -1067,18 +2307,20 @@
                         KatzeItem*       item,
                         MidoriBookmarks* bookmarks)
 {
+    KatzeItem* root = KATZE_ITEM (bookmarks->bookmarks_db);
     GtkWidget* menu;
     GtkWidget* menuitem;
 
     menu = gtk_menu_new ();
-    if (KATZE_ITEM_IS_FOLDER (item))
+    if ((item == root)
+        || KATZE_ITEM_IS_FOLDER (item))
     {
         gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri <> ''", NULL, item, FALSE);
 
         midori_bookmarks_popup_item (menu,
-            STOCK_TAB_NEW, _("Open all in _Tabs"), item, 
-            (!child_bookmarks_count ? NULL : midori_bookmarks_open_in_tab_activate_cb), 
+            STOCK_TAB_NEW, _("Open all in _Tabs"), item,
+            (!child_bookmarks_count ? NULL : midori_bookmarks_open_in_tab_activate_cb),
             bookmarks);
     }
     else
@@ -1094,11 +2336,59 @@
     gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
     gtk_widget_show (menuitem);
     midori_bookmarks_popup_item (menu, GTK_STOCK_EDIT, NULL,
-        item, midori_bookmarks_edit_clicked_cb, bookmarks);
-    midori_bookmarks_popup_item (menu, GTK_STOCK_DELETE, NULL,
-        item, midori_bookmarks_delete_clicked_cb, bookmarks);
-
-    katze_widget_popup (widget, GTK_MENU (menu), event, KATZE_MENU_POSITION_CURSOR);
+        item, (item == root) ? NULL : midori_bookmarks_edit_clicked_cb, bookmarks);
+    midori_bookmarks_popup_item (menu, GTK_STOCK_DELETE, NULL,
+        item, (item == root) ? NULL : midori_bookmarks_delete_clicked_cb, bookmarks);
+
+    katze_widget_popup (widget, GTK_MENU (menu), event, KATZE_MENU_POSITION_CURSOR);
+}
+
+static void
+midori_bookmarks_multi_popup (GtkWidget*       widget,
+                              GdkEventButton*  event,
+                              MidoriBookmarks* bookmarks,
+                              GtkTreeModel*    model,
+                              gint             count,
+                              GList*           rows)
+{
+    GtkWidget* menu;
+    GtkWidget* menuitem;
+
+    menu = gtk_menu_new ();
+
+    midori_bookmarks_popup_item (menu,
+        STOCK_TAB_NEW, _("Open all in _Tabs"),
+        KATZE_ITEM(bookmarks->bookmarks_db), midori_bookmarks_open_in_tab_activate_cb, bookmarks);
+    menuitem = gtk_separator_menu_item_new ();
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
+    gtk_widget_show (menuitem);
+
+    midori_bookmarks_popup_item (menu, GTK_STOCK_EDIT, NULL,
+        NULL, NULL, bookmarks);
+    midori_bookmarks_popup_item (menu, GTK_STOCK_DELETE, NULL,
+        KATZE_ITEM(bookmarks->bookmarks_db), midori_bookmarks_delete_clicked_cb, bookmarks);
+
+    katze_widget_popup (widget, GTK_MENU (menu), event, KATZE_MENU_POSITION_CURSOR);
+}
+
+static gboolean
+midori_bookmarks_do_block_selection (GtkTreeSelection *selection,
+                                     GtkTreeModel *model,
+                                     GtkTreePath *path,
+                                     gboolean path_currently_selected,
+                                     gpointer data)
+{
+    return FALSE;
+}
+
+static gboolean
+midori_bookmarks_do_not_block_selection (GtkTreeSelection *selection,
+                                         GtkTreeModel *model,
+                                         GtkTreePath *path,
+                                         gboolean path_currently_selected,
+                                         gpointer data)
+{
+    return TRUE;
 }
 
 static gboolean
@@ -1109,32 +2399,194 @@
     GtkTreeModel* model;
     GtkTreeIter iter;
 
-    if (event->button != 2 && event->button != 3)
+    if (bookmarks->pending_event)
+    {
+        GtkTreeView* treeview = GTK_TREE_VIEW(widget);
+        GtkTreeSelection* selection = gtk_tree_view_get_selection (treeview);
+        gint x = bookmarks->stock_pending_event.x;
+        gint y = bookmarks->stock_pending_event.y;
+
+        bookmarks->pending_event = NULL;
+        gtk_tree_selection_set_select_function (
+            selection, midori_bookmarks_do_not_block_selection, NULL, NULL);
+
+        if (x != event->x || y != event->y)
+            return FALSE;
+    }
+
+    if (event->button == 3)
+        return TRUE;
+
+    if (event->button != 2)
         return FALSE;
 
     if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (widget), &model, &iter))
     {
+        gboolean done = FALSE;
         KatzeItem* item;
 
         gtk_tree_model_get (model, &iter, 0, &item, -1);
 
-        if (event->button == 2)
+        if (KATZE_ITEM_IS_BOOKMARK (item))
         {
-            const gchar* uri;
-            if (KATZE_ITEM_IS_BOOKMARK (item) && (uri = katze_item_get_uri (item)) && *uri)
+            MidoriBrowser* browser = midori_browser_get_for_widget (widget);
+            GtkWidget* view = midori_bookmarks_open_bookmark_in_tab (
+                item, browser);
+
+            if (widget)
             {
-                MidoriBrowser* browser = midori_browser_get_for_widget (widget);
-                GtkWidget* view = midori_browser_add_uri (browser, uri);
-                midori_browser_set_current_tab (browser, view);
+                midori_browser_set_current_tab_smartly (browser, view);
+                done = TRUE;
             }
         }
-        else
-            midori_bookmarks_popup (widget, event, item, bookmarks);
-
-        if (item != NULL)
-            g_object_unref (item);
-        return TRUE;
-    }
+
+        g_object_unref (item);
+
+        return done;
+    }
+
+    return FALSE;
+}
+
+static gboolean
+midori_bookmarks_block_selection(GtkWidget*       widget,
+                                 GdkEventButton*  event,
+                                 MidoriBookmarks* bookmarks)
+{
+    GtkTreeView* treeview = GTK_TREE_VIEW(widget);
+    GtkTreePath* path;
+    GtkTreeSelection* selection;
+    gint cell_x;
+    gint cell_y;
+
+    if (!gtk_tree_view_get_path_at_pos (
+            treeview, event->x, event->y,
+            &path, NULL, &cell_x, &cell_y))
+        return FALSE;
+
+    gtk_widget_grab_focus (widget);
+
+    selection = gtk_tree_view_get_selection (treeview);
+
+    if (gtk_tree_selection_path_is_selected (selection, path)
+        && !(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
+    {
+        bookmarks->pending_event = &bookmarks->stock_pending_event;
+        bookmarks->stock_pending_event.x = event->x;
+        bookmarks->stock_pending_event.y = event->y;
+        gtk_tree_selection_set_select_function (
+            selection, midori_bookmarks_do_block_selection, NULL, NULL);
+    }
+    else
+    {
+        bookmarks->pending_event = NULL;
+        gtk_tree_selection_set_select_function (
+            selection, midori_bookmarks_do_not_block_selection, NULL, NULL);
+    }
+
+    return FALSE;
+}
+
+static gboolean
+midori_bookmarks_button_press_event_cb (GtkWidget*       widget,
+                                        GdkEventButton*  event,
+                                        MidoriBookmarks* bookmarks)
+{
+    GtkTreeView* treeview = GTK_TREE_VIEW(widget);
+    GtkTreePath* path;
+    GtkTreeSelection* selection;
+    GtkTreeModel* model;
+    gint selected;
+    GList* rows;
+    gint cell_x;
+    gint cell_y;
+
+    if (event->button == 1)
+        return midori_bookmarks_block_selection (widget, event, bookmarks);
+
+    if (event->button != 3)
+        return FALSE;
+
+    selection = gtk_tree_view_get_selection (treeview);
+
+    if (!gtk_tree_view_get_path_at_pos (
+            treeview, event->x, event->y,
+            &path, NULL, &cell_x, &cell_y))
+    {
+        /* FIXME: popup opening below treeview
+         * Rationale: the user is actually in ROOT folder
+         * we may need to have a non editable, non deletable, ROOT folder popup
+         *    Open all in Tabs
+         *    Separator
+         *    Edit [inactive]
+         *    Delete [inactive]
+         * Here we just mimic the Files behaviour:
+         * 1- unselect all
+         * 2- let popup based on selection process
+         */
+
+        gtk_tree_selection_unselect_all (selection);
+    }
+    else if (!gtk_tree_selection_path_is_selected (selection, path))
+    {
+        /* Use case: popup opening on item not in selection
+         * Rationale: the user is addressing a single item not in selection
+         * we may need a single item popup with callbacks working on the item,
+         * not the selection.
+         * Here we just mimic the Files behaviour:
+         * 1- change the selection to the item the popup is opened on
+         * 2- let popup based on selection process
+         */
+
+        gtk_tree_selection_unselect_all (selection);
+        gtk_tree_selection_select_path (selection, path);
+    }
+
+    selected = katze_tree_view_get_selected_rows(GTK_TREE_VIEW (widget), &model, &rows);
+
+    if (!selected)
+    {
+        KatzeItem* root = KATZE_ITEM (bookmarks->bookmarks_db);
+
+        midori_bookmarks_popup (widget, event, root, bookmarks);
+
+        return TRUE;
+    }
+
+    if (selected == 1)
+    {
+        GtkTreeIter iter;
+        KatzeItem* item;
+
+        if (!gtk_tree_model_get_iter (
+                model, &iter, (GtkTreePath *)g_list_nth_data (rows, 0)))
+        {
+            g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+
+            return FALSE;
+        }
+
+        gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+        midori_bookmarks_popup (widget, event, item, bookmarks);
+
+        g_object_unref (item);
+
+        g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+
+        return TRUE;
+    }
+
+    if (selected > 1)
+    {
+        midori_bookmarks_multi_popup (widget, event, bookmarks,
+            model, selected, rows);
+
+        g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+
+        return TRUE;
+    }
+
     return FALSE;
 }
 
@@ -1165,39 +2617,74 @@
     }
 }
 
-static void
-midori_bookmarks_row_expanded_cb (GtkTreeView*     treeview,
-                                  GtkTreeIter*     iter,
-                                  GtkTreePath*     path,
-                                  MidoriBookmarks* bookmarks)
+static gboolean
+midori_bookmarks_test_expand_row_cb (GtkTreeView*     treeview,
+				     GtkTreeIter*     iter,
+				     GtkTreePath*     path,
+				     MidoriBookmarks* bookmarks)
 {
     GtkTreeModel* model;
+    GtkTreeIter  child;
     KatzeItem* item;
+    gint64 id;
 
     model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
+
     gtk_tree_model_get (model, iter, 0, &item, -1);
+
+    g_return_val_if_fail (KATZE_IS_ITEM(item), TRUE);
+
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
+    id = katze_item_get_meta_integer (item, "id");
+
+    g_object_unref (item);
+
+    while (gtk_tree_model_iter_children (model, &child, iter))
+        gtk_tree_store_remove (GTK_TREE_STORE (model), &child);
+    /* That's an invisible dummy, so we always have an expander */
+    gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &child, iter,
+        0, 0, NULL, -1);
+
+    g_signal_handlers_unblock_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
     midori_bookmarks_read_from_db_to_model (bookmarks, GTK_TREE_STORE (model),
-                                            iter, katze_item_get_meta_integer (item, "id"), NULL);
-    g_object_unref (item);
+        iter, id, NULL);
+
+    return FALSE;
 }
 
 static void
 midori_bookmarks_row_collapsed_cb (GtkTreeView *treeview,
                                    GtkTreeIter *parent,
                                    GtkTreePath *path,
-                                   gpointer     user_data)
+                                   MidoriBookmarks* bookmarks)
 {
     GtkTreeModel* model;
     GtkTreeStore* treestore;
     GtkTreeIter child;
 
     model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
+
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
     treestore = GTK_TREE_STORE (model);
     while (gtk_tree_model_iter_nth_child (model, &child, parent, 0))
         gtk_tree_store_remove (treestore, &child);
     /* That's an invisible dummy, so we always have an expander */
     gtk_tree_store_insert_with_values (treestore, &child, parent,
         0, 0, NULL, -1);
+
+    g_signal_handlers_block_by_func (model,
+        midori_bookmarks_row_deleted_cb,
+        bookmarks);
+
 }
 
 static void
@@ -1205,26 +2692,27 @@
                                        MidoriBookmarks  *bookmarks)
 {
     midori_bookmarks_toolbar_update (bookmarks);
+    midori_bookmarks_statusbar_update (bookmarks);
 }
 
 static KatzeItem*
 midori_bookmarks_get_item_at_pos (GtkTreeView *treeview,
                                   gint x, gint y)
-{    
+{
     GtkTreeModel* model = gtk_tree_view_get_model (treeview);
     GtkTreePath* path;
     GtkTreeIter iter;
     KatzeItem* item = NULL;
 
     gtk_tree_view_get_path_at_pos (treeview, x, y,
-                                   &path, NULL, NULL, NULL);
-    
+        &path, NULL, NULL, NULL);
+
     if (!path)
         return NULL;
-    
+
     if (gtk_tree_model_get_iter (model, &iter, path))
         gtk_tree_model_get (model, &iter, 0, &item, -1);
-    
+
     gtk_tree_path_free (path);
 
     return item;
@@ -1296,7 +2784,7 @@
 
     if (bookmarks->hovering_item)
         g_object_unref (bookmarks->hovering_item);
-    
+
     bookmarks->hovering_item = NULL;
 
     g_object_set (browser, "statusbar-text", "", NULL);
@@ -1337,6 +2825,186 @@
         midori_bookmarks_filter_timeout_cb, bookmarks, NULL);
 }
 
+static GtkTargetEntry midori_bookmarks_dnd_target_entries[]=
+{
+    {MIDORI_BOOKMARKS_TREE_MODEL_TARGET, GTK_TARGET_SAME_WIDGET, 0},
+};
+
+#define MIDORI_BOOKMARKS_DND_NB_TARGET_ENTRIES      \
+  G_N_ELEMENTS (midori_bookmarks_dnd_target_entries)
+
+static guint
+item_hash (gconstpointer item)
+{
+    gint64 id = katze_item_get_meta_integer (KATZE_ITEM (item), "id");
+    return g_int64_hash (&id);
+}
+
+static gboolean
+item_equal (gconstpointer item_a, gconstpointer item_b)
+{
+    gint64 id_a = katze_item_get_meta_integer (KATZE_ITEM (item_a), "id");
+    gint64 id_b = katze_item_get_meta_integer (KATZE_ITEM (item_b), "id");
+    return (id_a == id_b)? TRUE : FALSE;
+}
+
+static gboolean
+midori_bookmarks_idle_func (gpointer data)
+{
+    MidoriBookmarks* bookmarks = MIDORI_BOOKMARKS (data);
+    GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
+    GHashTableIter hash_iter;
+    gpointer key, value;
+    GList* list_iter;
+
+    /* update remaining additions */
+    assert_reorder_are_folders (model, bookmarks);
+    for (list_iter = bookmarks->added_paths; list_iter ; list_iter = g_list_next (list_iter))
+    {
+        GtkTreePath* path = (GtkTreePath*)list_iter->data;
+
+        add_parent_to_reorder (model, path, bookmarks);
+        assert_reorder_are_folders (model, bookmarks);
+    }
+
+    g_list_free_full (bookmarks->added_paths, (GDestroyNotify) gtk_tree_path_free);
+    bookmarks->added_paths = NULL;
+
+    /* do actual reordering */
+    for (list_iter = bookmarks->reordered_paths; list_iter ; list_iter = g_list_next (list_iter))
+    {
+        GtkTreeIter local_iter;
+        GtkTreePath* path = (GtkTreePath*)list_iter->data;
+
+        if (gtk_tree_path_get_depth (path))
+        {
+            GtkTreeIter parent;
+
+            if (gtk_tree_model_get_iter (model, &parent, path))
+            {
+                KatzeItem *item;
+                gint64 id;
+
+                gtk_tree_model_get (model, &parent, 0, &item, -1);
+
+                g_assert (KATZE_ITEM_IS_FOLDER (item));
+
+                id = katze_item_get_meta_integer (item, "id");
+
+                if (gtk_tree_model_iter_children (model, &local_iter, &parent))
+                    midori_bookmarks_set_item_positon(model, &local_iter, id, bookmarks);
+
+                /* update folder array for menu update */
+                katze_array_update (KATZE_ARRAY (item));
+
+                g_object_unref (item);
+            }
+        }
+        else
+        {
+            if (gtk_tree_model_get_iter_first (model, &local_iter))
+                midori_bookmarks_set_item_positon(model, &local_iter, 
+                    katze_item_get_meta_integer (KATZE_ITEM (bookmarks->bookmarks_db), "id"),
+                    bookmarks);
+
+            g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
+                midori_bookmarks_update_cb,
+                bookmarks);
+
+            /* update folder array for menu update */
+            katze_array_update (KATZE_ARRAY (bookmarks->bookmarks_db));
+
+            g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
+                midori_bookmarks_update_cb,
+                bookmarks);
+        }
+    }
+
+    g_list_free_full (bookmarks->reordered_paths, (GDestroyNotify) gtk_tree_path_free);
+    bookmarks->reordered_paths = NULL;
+
+    /* then finalize updates */
+    g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
+        midori_bookmarks_update_item_cb,
+        bookmarks);
+
+    g_hash_table_iter_init (&hash_iter, bookmarks->updated_items);
+
+    while (g_hash_table_iter_next (&hash_iter, &key, &value))
+    {
+        midori_bookmarks_db_update_item (bookmarks->bookmarks_db, KATZE_ITEM (value));
+        g_object_unref (value);
+    }
+
+    g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
+        midori_bookmarks_update_item_cb,
+        bookmarks);
+
+    g_hash_table_remove_all (bookmarks->updated_items);
+
+    /* process pending additions of inserted bookmarks */
+    for (list_iter = bookmarks->pending_inserts; list_iter; list_iter = g_list_next (list_iter))
+    {
+        KatzeItem *item = KATZE_ITEM (list_iter->data);
+        gint64 id = katze_item_get_meta_integer (item, "id");
+        GtkTreeIter iter;
+
+        if (!midori_bookmarks_reach_item (model, &iter, id))
+            midori_bookmarks_add_item (item, bookmarks);
+
+        g_object_unref (item);
+    }
+
+    g_list_free (bookmarks->pending_inserts);
+    bookmarks->pending_inserts = NULL;
+    return midori_bookmarks_idle_pending (bookmarks);
+}
+
+static void
+midori_bookmarks_update_item (MidoriBookmarks* bookmarks, KatzeItem *item)
+{
+    midori_bookmarks_idle_start (bookmarks);
+
+    if (g_hash_table_lookup (bookmarks->updated_items, item))
+        return;
+
+    g_object_ref (item);
+    g_hash_table_insert (bookmarks->updated_items, item, item);
+}
+
+static void
+midori_bookmarks_idle_remove_item (MidoriBookmarks* bookmarks, KatzeItem *item)
+{
+    gpointer found;
+
+    if (KATZE_ITEM_IS_FOLDER (item))
+    {
+        gint64 id = katze_item_get_meta_integer (item, "id");
+        GHashTableIter iter;
+        gpointer key, value;
+
+        g_hash_table_iter_init (&iter, bookmarks->updated_items);
+
+        while (g_hash_table_iter_next (&iter, &key, &value))
+        {
+            KatzeItem *hash_item = KATZE_ITEM(key);
+
+            gint64 parentid = katze_item_get_meta_integer (hash_item, "parentid");
+            if (parentid == id)
+            {
+                g_hash_table_iter_remove (&iter);
+                g_object_unref (hash_item);
+            }
+        }
+    }
+
+    if ((found = g_hash_table_lookup (bookmarks->updated_items, item)) != NULL)
+    {
+        g_hash_table_remove (bookmarks->updated_items, found);
+        g_object_unref (found);
+    }
+}
+
 static void
 midori_bookmarks_init (MidoriBookmarks* bookmarks)
 {
@@ -1349,6 +3017,8 @@
     GtkCellRenderer* renderer_text;
     GtkTreeSelection* selection;
 
+    bookmarks->pending_event = NULL;
+
     /* Create the filter entry */
     entry = sokoke_search_entry_new (_("Search Bookmarks"));
     g_signal_connect_after (entry, "changed",
@@ -1359,7 +3029,7 @@
     gtk_box_pack_start (GTK_BOX (bookmarks), box, FALSE, FALSE, 5);
 
     /* Create the treeview */
-    model = gtk_tree_store_new (2, KATZE_TYPE_ITEM, G_TYPE_STRING);
+    model = midori_bookmarks_tree_store_new (2, KATZE_TYPE_ITEM, G_TYPE_STRING);
     treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
     gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
     gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (treeview), 1);
@@ -1376,19 +3046,32 @@
         (GtkTreeCellDataFunc)midori_bookmarks_treeview_render_text_cb,
         treeview, NULL);
     gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
-    gtk_tree_view_set_reorderable (GTK_TREE_VIEW (treeview), TRUE);
+    gtk_tree_view_set_reorderable (GTK_TREE_VIEW (treeview), FALSE);
+    gtk_tree_view_enable_model_drag_source (
+        GTK_TREE_VIEW (treeview),
+        GDK_BUTTON1_MASK,
+        midori_bookmarks_dnd_target_entries,
+        MIDORI_BOOKMARKS_DND_NB_TARGET_ENTRIES,
+        GDK_ACTION_MOVE|GDK_ACTION_LINK);
+    gtk_tree_view_enable_model_drag_dest (
+        GTK_TREE_VIEW (treeview),
+        midori_bookmarks_dnd_target_entries,
+        MIDORI_BOOKMARKS_DND_NB_TARGET_ENTRIES,
+        GDK_ACTION_MOVE|GDK_ACTION_LINK);
     g_object_unref (model);
     g_object_connect (treeview,
                       "signal::row-activated",
                       midori_bookmarks_row_activated_cb, bookmarks,
+                      "signal::button-press-event",
+                      midori_bookmarks_button_press_event_cb, bookmarks,
                       "signal::button-release-event",
                       midori_bookmarks_button_release_event_cb, bookmarks,
                       "signal::key-release-event",
                       midori_bookmarks_key_release_event_cb, bookmarks,
                       "signal::popup-menu",
                       midori_bookmarks_popup_menu_cb, bookmarks,
-                      "signal::row-expanded",
-                      midori_bookmarks_row_expanded_cb, bookmarks,
+                      "signal::test-expand-row",
+                      midori_bookmarks_test_expand_row_cb, bookmarks,
                       "signal::row-collapsed",
                       midori_bookmarks_row_collapsed_cb, bookmarks,
                       "signal::enter-notify-event",
@@ -1398,18 +3081,27 @@
                       "signal::leave-notify-event",
                       midori_bookmarks_leave_notify_event_cb, bookmarks,
                       NULL);
-    gtk_widget_add_events (GTK_WIDGET (treeview), 
-                           GDK_POINTER_MOTION_MASK
-                           | GDK_POINTER_MOTION_HINT_MASK);
+
+    MIDORI_BOOKMARKS_TREE_STORE (model)->_view = GTK_TREE_VIEW (treeview);
+
+    gtk_widget_add_events (GTK_WIDGET (treeview),
+        GDK_POINTER_MOTION_MASK
+        | GDK_POINTER_MOTION_HINT_MASK);
 
     selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
+    gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
     g_signal_connect_after (selection, "changed",
-                            G_CALLBACK (midori_bookmarks_selection_changed_cb),
-                            bookmarks);
+        G_CALLBACK (midori_bookmarks_selection_changed_cb),
+        bookmarks);
     gtk_widget_show (treeview);
     gtk_box_pack_start (GTK_BOX (bookmarks), treeview, TRUE, TRUE, 0);
     bookmarks->treeview = treeview;
+    bookmarks->pending_inserts = NULL;
     bookmarks->hovering_item = NULL;
+    bookmarks->pending_inserts = NULL;
+    bookmarks->updated_items = g_hash_table_new (item_hash, item_equal);
+    bookmarks->added_paths = NULL;
+    bookmarks->reordered_paths = NULL;
 }
 
 static void
@@ -1420,5 +3112,16 @@
     if (bookmarks->app)
         g_object_unref (bookmarks->app);
     if (bookmarks->hovering_item)
-	g_object_unref (bookmarks->hovering_item);
+        g_object_unref (bookmarks->hovering_item);
+
+    if (g_idle_remove_by_data (bookmarks))
+    {
+        g_list_free_full (bookmarks->pending_inserts, (GDestroyNotify) g_object_unref);
+        bookmarks->pending_inserts = NULL;
+        g_hash_table_unref (bookmarks->updated_items);
+        g_list_free_full (bookmarks->added_paths, (GDestroyNotify) gtk_tree_path_free);
+        bookmarks->added_paths = NULL;
+        g_list_free_full (bookmarks->reordered_paths, (GDestroyNotify) gtk_tree_path_free);
+        bookmarks->reordered_paths = NULL;
+    }
 }
 
=== modified file 'tests/bookmarks.c'
--- tests/bookmarks.c	2013-08-05 19:52:52 +0000
+++ tests/bookmarks.c	2014-01-26 19:44:25 +0000
@@ -128,7 +128,7 @@
         }
 
         db_items = midori_bookmarks_db_query_recursive (db_bookmarks,
-                           "*", "title='%q'", katze_item_get_name (test_item), FALSE);
+							"*", "title='%q'", katze_item_get_name (test_item), NULL, FALSE);
 
         /* FIXME g_assert_cmpint (katze_array_get_length (db_items), ==, 1); */
         db_item = katze_array_get_nth_item (db_items, 0);