Merge lp:~aauzi/midori/bookmarks-work into lp:midori

[André Auzi]

All is in revision 6164 commit message.
    Fix proposal for:
      #894143 Unable to select multiple bookmarks for moving/deleting
      #1116908 Bookmarkbar folder is not updated when bookmark is added to folder
      #1177553 Bookmark folder tree not reflected in bookmark bar and edit dialog
      #1179200 Bookmark folder tree collapsed on bookmarks update
      #1179624 Lack of visual feedback in bookmarks panel

    Implements:
      * bookmarks panel multiple selection DND delete and moves
      * katze items signals between bookmarks panel and bookmarks bar
      * correct handling of panel position on database retrieval
      * bookmarkbar folder trees
      * bookmark folder path is bookmark edit combo box
      * use of current selection for bookmark/folder creation parent folder
      * status bar updates and popup menus cosmetics
      * idle time database updates (speed feeling)

    Does not implement (maybe future work):
      * DND exchanges between bookmark bar and bookmark panel
      * DND bookmark creation

Considering the amount of changes I thought merging the different bugs myself may help :)

[Danielle Foré (danrabbit)]

Hey André, thanks for this huge work! I have a couple of problems to report however...

It seems for some reason there is a bunch of .po files scattered around your branch :p

Also, the build fails with:

../panels/midori-bookmarks.c: In function ‘midori_bookmarks_tree_store_drag_data_get’:
../panels/midori-bookmarks.c:903:23: error: dereferencing pointer to incomplete type
../panels/midori-bookmarks.c: In function ‘midori_bookmarks_tree_store_get_rows_drag_data’:
../panels/midori-bookmarks.c:1044:23: error: dereferencing pointer to incomplete type
../panels/midori-bookmarks.c:1047:23: error: dereferencing pointer to incomplete type
../panels/midori-bookmarks.c:1050:33: error: dereferencing pointer to incomplete type
../panels/midori-bookmarks.c: In function ‘midori_bookmarks_tree_store_row_drop_possible’:
../panels/midori-bookmarks.c:1112:23: error: dereferencing pointer to incomplete type
../panels/midori-bookmarks.c: In function ‘midori_bookmarks_tree_store_drag_data_received’:
../panels/midori-bookmarks.c:1229:23: error: dereferencing pointer to incomplete type

review: Needs Fixing

[André Auzi (aauzi)]

> Hey André, thanks for this huge work! I have a couple of problems to report
> however...
>
> It seems for some reason there is a bunch of .po files scattered around your
> branch :p
>
> Also, the build fails with:
>
> ../panels/midori-bookmarks.c: In function
> ‘midori_bookmarks_tree_store_drag_data_get’:
> ../panels/midori-bookmarks.c:903:23: error: dereferencing pointer to
> incomplete type
> ../panels/midori-bookmarks.c: In function
> ‘midori_bookmarks_tree_store_get_rows_drag_data’:
> ../panels/midori-bookmarks.c:1044:23: error: dereferencing pointer to
> incomplete type
> ../panels/midori-bookmarks.c:1047:23: error: dereferencing pointer to
> incomplete type
> ../panels/midori-bookmarks.c:1050:33: error: dereferencing pointer to
> incomplete type
> ../panels/midori-bookmarks.c: In function
> ‘midori_bookmarks_tree_store_row_drop_possible’:
> ../panels/midori-bookmarks.c:1112:23: error: dereferencing pointer to
> incomplete type
> ../panels/midori-bookmarks.c: In function
> ‘midori_bookmarks_tree_store_drag_data_received’:
> ../panels/midori-bookmarks.c:1229:23: error: dereferencing pointer to
> incomplete type

Hi Dan, no problem.

I'm glad there are so few problems on a first shoot :D

For the .po files I'm clueless so far but if your show me directions I'll do my best.

I'm concerned by the compilation errors you have.

Apparently, the GtkSelectionData structure is not exposed in your environment.

I'm building with gtk+-2.0 version : 2.24.16 on Fedora 18, let me know what is your environment, I'll see if I can figure out what happens.

[lp:~aauzi/midori/bookmarks-work]

6164. By André Auzi on 2013-05-21

Fix proposal for:
  #894143 Unable to select multiple bookmarks for moving/deleting
  #1116908 Bookmarkbar folder is not updated when bookmark is added to folder
  #1177553 Bookmark folder tree not reflected in bookmark bar and edit dialog
  #1179200 Bookmark folder tree collapsed on bookmarks update
  #1179624 Lack of visual feedback in bookmarks panel

Implements:
  * bookmarks panel multiple selection DND delete and moves
  * katze items signals between bookmarks panel and bookmarks bar
  * correct handling of panel position on database retrieval
  * bookmarkbar folder trees
  * bookmark folder path in bookmark edit combo box
  * use of current selection for bookmark/folder creation parent folder
  * status bar updates and popup menus cosmetics
  * idle time database updates (speed feeling)

Does not implement (maybe future work):
  * DND exchanges between bookmark bar and bookmark panel
  * DND bookmark creation

Notes:
  1-recommit with use of accessors for GtkSelectionData fields

6165. By André Auzi on 2013-05-21

merge lp:~aauzi/midori/bookmarks-work

[Danielle Foré (danrabbit)]

Hey André,

I think for the .po files, you can probably just delete any of them that aren't in the po directory and we'll know there's something really wrong if they regenerate :p

After your latest commit, the branch does build with Gtk 3.4 :) But I'm afraid there are issues >.<

I do have a problem that I can't access any bookmarks that are in a folder. Clicking the expander triangle does nothing. Double-clicking the folder expands, but as soon as I move the cursor it starts a drag operation.

Dragging any bookmarks in the sidepanel forces the Bookmarks Bar to open.

I think for the statusbar feature, it should probably only show on hover as is the behavior with links in the web view (but it is a cool feature!)

review: Needs Fixing

[Danielle Foré (danrabbit)]

Hey André,

it looks like the .po file thing is actually our fault. Something went weird with LP translations.

But also I want to say if possible it would be great to split this up into separate feature branches that we could merge individually. This is quite a large diff and is very difficult to review. It would probably be a lot safer to merge one feature at a time.

If one branch relies on another, that's okay! LP has a feature where you can mark one branch as being a pre-requisite of another so we know what order to merge them in.

Thanks again for your hard work!

[André Auzi (aauzi)]

Hi Dan,

> I think for the .po files, you can probably just delete any of them that
> aren't in the po directory and we'll know there's something really wrong if
> they regenerate :p

it's OK on my side, no more .po after deletion and clean build.

> After your latest commit, the branch does build with Gtk 3.4 :) But I'm afraid
> there are issues >.<

Great news! and issues were expected, it's all the point of testing and reviews, isn't it?

> I do have a problem that I can't access any bookmarks that are in a folder.
> Clicking the expander triangle does nothing. Double-clicking the folder
> expands, but as soon as I move the cursor it starts a drag operation.

OK, I believe the ugly trick used to keep the multi selection before dragging does not integrate well with Gtk 3. I'll work on that.

> Dragging any bookmarks in the sidepanel forces the Bookmarks Bar to open.

Oups! Now I have to see how we hide the bookmark bar. I'll work on that too.

> I think for the statusbar feature, it should probably only show on hover as is
> the behavior with links in the web view (but it is a cool feature!)

Sounds good, I will have a look on the web view and see how I can reproduce the behaviour.

Thanks for the valuable feedback.

[André Auzi (aauzi)]

Hi Dan,

> But also I want to say if possible it would be great to split this up into
> separate feature branches that we could merge individually. This is quite a
> large diff and is very difficult to review. It would probably be a lot safer
> to merge one feature at a time.

No problem, I have the increments ready, it's just a matter of configuration management ;)

> Thanks again for your hard work!

you're welcome. Thank you for midori, it's cool to hack in.

Now it's time to go to the office :D

[André Auzi (aauzi)]

OK, it's time for a follow up.

So far I've reworked the proposal in three independent branches (in increasing order of complexity):
1. lp:~aauzi/midori/fix-1177553: Bookmark folder tree not reflected in bookmark bar and edit dialog
2. lp:~aauzi/midori/fix-1179624: Lack of visual feedback in bookmarks panel
3. lp:~aauzi/midori/fix-1179200: Bookmark folder tree collapsed on bookmarks update

The reported issues/remarks taken into account are:
> Dragging any bookmarks in the sidepanel forces the Bookmarks Bar to open
=> fixed in lp:~aauzi/midori/fix-1179200

> I think for the statusbar feature, it should probably only show on hover as is
> the behavior with links in the web view (but it is a cool feature!)
=> reworked into lp:~aauzi/midori/fix-1179624

There's still an upcoming one:
> I do have a problem that I can't access any bookmarks that are in a folder.
> Clicking the expander triangle does nothing. Double-clicking the folder
> expands, but as soon as I move the cursor it starts a drag operation.
=> it's work in progress
   it'll show up in a branch related to bug
     #894143 Unable to select multiple bookmarks for moving/deleting, lp:~aauzi/midori/fix-894143
   the merge of this branch will have to come after the merge of branches:
     lp:~aauzi/midori/fix-1179200
     lp:~aauzi/midori/fix-1179624
   the remaining activities are:
   * rework hovering to take multi selection into account (~1day)
   * integrate with Gtk+3 to investigate the misbehaviour (hopefully no more than ~1day)
   I will propose it for merge when it's ready.

I therefore propose to close this review and switch to the reviews of the fore mentioned branches.

[Danielle Foré (danrabbit)]

Great! Thanks André! I'll go ahead and close this review then and we can get started on merging those smaller branches :)

review: Disapprove

Unmerged revisions

6165. By André Auzi on 2013-05-21

merge lp:~aauzi/midori/bookmarks-work

6164. By André Auzi on 2013-05-21

Fix proposal for:
  #894143 Unable to select multiple bookmarks for moving/deleting
  #1116908 Bookmarkbar folder is not updated when bookmark is added to folder
  #1177553 Bookmark folder tree not reflected in bookmark bar and edit dialog
  #1179200 Bookmark folder tree collapsed on bookmarks update
  #1179624 Lack of visual feedback in bookmarks panel

Implements:
  * bookmarks panel multiple selection DND delete and moves
  * katze items signals between bookmarks panel and bookmarks bar
  * correct handling of panel position on database retrieval
  * bookmarkbar folder trees
  * bookmark folder path in bookmark edit combo box
  * use of current selection for bookmark/folder creation parent folder
  * status bar updates and popup menus cosmetics
  * idle time database updates (speed feeling)

Does not implement (maybe future work):
  * DND exchanges between bookmark bar and bookmark panel
  * DND bookmark creation

Notes:
  1-recommit with use of accessors for GtkSelectionData fields

=== modified file 'katze/katze-array.c'
--- katze/katze-array.c	2012-08-08 23:02:56 +0000
+++ katze/katze-array.c	2013-05-21 05:35:32 +0000
@@ -42,6 +42,9 @@
     (*add_item)               (KatzeArray* array,
                                gpointer    item);
     void
+    (*update_item)            (KatzeArray* array,
+                               gpointer    item);
+    void
     (*remove_item)            (KatzeArray* array,
                                gpointer    item);
     void
@@ -59,6 +62,7 @@
 
 enum {
     ADD_ITEM,
+    UPDATE_ITEM,
     REMOVE_ITEM,
     MOVE_ITEM,
     CLEAR,
@@ -95,6 +99,13 @@
 }
 
 static void
+_katze_array_update_item (KatzeArray* array,
+			  gpointer    item)
+{
+    _katze_array_update (array);
+}
+
+static void
 _katze_array_remove_item (KatzeArray* array,
                           gpointer   item)
 {
@@ -147,6 +158,17 @@
         G_TYPE_NONE, 1,
         G_TYPE_POINTER);
 
+    signals[UPDATE_ITEM] = g_signal_new (
+        "update-item",
+        G_TYPE_FROM_CLASS (class),
+        (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+        G_STRUCT_OFFSET (KatzeArrayClass, add_item),
+        0,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE, 1,
+        G_TYPE_POINTER);
+
     signals[REMOVE_ITEM] = g_signal_new (
         "remove-item",
         G_TYPE_FROM_CLASS (class),
@@ -213,6 +235,7 @@
     gobject_class->finalize = katze_array_finalize;
 
     class->add_item = _katze_array_add_item;
+    class->update_item = _katze_array_update_item;
     class->remove_item = _katze_array_remove_item;
     class->move_item = _katze_array_move_item;
     class->clear = _katze_array_clear;
@@ -301,6 +324,23 @@
 }
 
 /**
+ * katze_array_update_item:
+ * @array: a #KatzeArray
+ * @item: an item
+ *
+ * Notify an update of the item of the array.
+ *
+ **/
+void
+katze_array_update_item (KatzeArray* array,
+                      gpointer    item)
+{
+    g_return_if_fail (KATZE_IS_ARRAY (array));
+
+    g_signal_emit (array, signals[UPDATE_ITEM], 0, item);
+}
+
+/**
  * katze_array_remove_item:
  * @array: a #KatzeArray
  * @item: an item

=== modified file 'katze/katze-array.h'
--- katze/katze-array.h	2011-01-19 20:58:26 +0000
+++ katze/katze-array.h	2013-05-21 05:35:32 +0000
@@ -47,6 +47,10 @@
                                     gpointer      item);
 
 void
+katze_array_update_item            (KatzeArray*   array,
+                                    gpointer      item);
+
+void
 katze_array_remove_item            (KatzeArray*   array,
                                     gpointer      item);
 

=== modified file 'katze/katze-item.c'
--- katze/katze-item.c	2013-02-21 21:36:30 +0000
+++ katze/katze-item.c	2013-05-21 05:35:32 +0000
@@ -314,11 +314,12 @@
 katze_item_set_name (KatzeItem*   item,
                      const gchar* name)
 {
+    gchar* pname = item->name;
     g_return_if_fail (KATZE_IS_ITEM (item));
 
     katze_assign (item->name, g_strdup (name));
-    if (item->parent)
-        katze_array_update ((KatzeArray*)item->parent);
+    if (item->parent && g_strcmp0(name, pname))
+        katze_array_update((KatzeArray*)item->parent);
     g_object_notify (G_OBJECT (item), "name");
 }
 
@@ -418,11 +419,12 @@
 katze_item_set_icon (KatzeItem*   item,
                      const gchar* icon)
 {
+    gchar *picon = katze_item_get_meta_string (item, "icon");
     g_return_if_fail (KATZE_IS_ITEM (item));
 
     katze_item_set_meta_string (item, "icon", icon);
-    if (item->parent)
-        katze_array_update ((KatzeArray*)item->parent);
+    if (item->parent && g_strcmp0(icon, picon))
+        katze_array_update_item ((KatzeArray*)item->parent, item);
     g_object_notify (G_OBJECT (item), "icon");
 }
 
@@ -445,8 +447,13 @@
 
     g_return_val_if_fail (KATZE_IS_ITEM (item), NULL);
 
-    if (widget && KATZE_ITEM_IS_FOLDER (item))
-        return gtk_widget_render_icon (widget, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
+    if (widget)
+    {
+	if (KATZE_ITEM_IS_FOLDER (item))
+	    return gtk_widget_render_icon (widget, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
+	if (KATZE_ITEM_IS_BOOKMARK (item) && katze_item_get_meta_boolean (item, "app"))
+	    return gtk_widget_render_icon (widget, GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU, NULL);
+    }
     if ((pixbuf = midori_paths_get_icon (katze_item_get_icon (item), NULL)))
         return pixbuf;
     if ((pixbuf = midori_paths_get_icon (item->uri, widget)))
@@ -526,7 +533,8 @@
     gtk_widget_show (image);
     if (pixbuf != NULL)
         g_object_unref (pixbuf);
-    if (KATZE_ITEM_IS_FOLDER (item))
+    if (KATZE_ITEM_IS_FOLDER (item) 
+	|| (KATZE_ITEM_IS_BOOKMARK (item) && katze_item_get_meta_boolean (item, "app")))
         return image;
     g_object_set_data (G_OBJECT (image), "KatzeItem", g_object_ref (item));
     g_signal_connect (image, "destroy",

=== modified file 'katze/katze-utils.c'
--- katze/katze-utils.c	2013-04-16 23:16:24 +0000
+++ katze/katze-utils.c	2013-05-21 05:35:32 +0000
@@ -984,12 +984,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,

=== modified file 'katze/katze-utils.h'
--- katze/katze-utils.h	2013-04-16 22:10:56 +0000
+++ katze/katze-utils.h	2013-05-21 05:35:32 +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,

=== modified file 'midori/midori-array.c'
--- midori/midori-array.c	2013-04-16 23:16:24 +0000
+++ midori/midori-array.c	2013-05-21 05:35:32 +0000
@@ -1109,6 +1109,12 @@
  * @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 
+ *   @order is inserted before title.
+ *   order then becomes : 
+ *      (uri='') ASC, @order title DESC 
  * @recursive: if %TRUE include children
  *
  * Stores the result in a #KatzeArray.
@@ -1122,6 +1128,7 @@
                               const gchar* fields,
                               const gchar* condition,
                               const gchar* value,
+                              const gchar* order,
                               gboolean     recursive)
 {
     sqlite3* db;
@@ -1138,7 +1145,8 @@
     g_return_val_if_fail (db != NULL, NULL);
 
     sqlcmd = g_strdup_printf ("SELECT %s FROM bookmarks WHERE %s "
-                              "ORDER BY (uri='') ASC, title DESC", fields, condition);
+                              "ORDER BY (uri='') ASC, %s title DESC", 
+			      fields, condition, order ? order : "");
     if (strstr (condition, "%q"))
     {
         sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
@@ -1159,7 +1167,7 @@
             gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
                 katze_item_get_meta_integer (item, "id"));
             KatzeArray* subarray = midori_array_query_recursive (bookmarks,
-                fields, "parentid=%q", parentid, TRUE);
+		fields, "parentid=%q", parentid, order, TRUE);
             katze_item_set_name (KATZE_ITEM (subarray), katze_item_get_name (item));
             katze_array_add_item (array, subarray);
 
@@ -1176,6 +1184,12 @@
  * @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 
+ *   @order is inserted before title.
+ *   order then becomes : 
+ *      (uri='') ASC, @order title DESC 
  *
  * Stores the result in a #KatzeArray.
  *
@@ -1189,8 +1203,128 @@
 midori_array_query (KatzeArray*  bookmarks,
                     const gchar* fields,
                     const gchar* condition,
-                    const gchar* value)
-{
-    return midori_array_query_recursive (bookmarks, fields, condition, value, FALSE);
+                    const gchar* value,
+                    const gchar* order)
+{
+    return midori_array_query_recursive (bookmarks, fields, condition, value, order, FALSE);
+}
+
+static gint64
+count_from_sqlite (sqlite3*     db,
+		   const gchar* sqlcmd)
+{
+    gint64 count = -1;
+    sqlite3_stmt* stmt;
+    gint result;
+    
+    result = sqlite3_prepare_v2 (db, sqlcmd, -1, &stmt, NULL);
+    if (result != SQLITE_OK)
+        return -1;
+
+    g_assert (sqlite3_column_count (stmt) == 1);
+    
+    if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
+	count = sqlite3_column_int64(stmt, 0);
+
+    sqlite3_clear_bindings (stmt);
+    sqlite3_reset (stmt);
+
+    return count;
+}
+
+/**
+ * midori_array_count_recursive:
+ * @array: the main bookmark array
+ * @condition: condition, like "folder = '%q'"
+ * @value: a value to be inserted if @condition contains %q
+ * @recursive: if %TRUE include children
+ *
+ * Return value: the number of elements on success, -1 otherwise
+ *
+ * Since: 0.5.1
+ **/
+gint64
+midori_array_count_recursive (KatzeArray*  bookmarks,
+			      const gchar* condition,
+                              const gchar* value,
+			      KatzeItem*   folder,
+                              gboolean     recursive)
+{
+    gint64 count = -1;
+    gint64 id = -1;
+    sqlite3* db;
+    gchar* sqlcmd;
+    char* sqlcmd_value;
+    KatzeArray* array;
+    KatzeItem* item;
+    GList* list;
+    gchar* id_str;
+
+    g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), -1);
+    g_return_val_if_fail (!folder || KATZE_ITEM_IS_FOLDER (folder), -1);
+    g_return_val_if_fail (condition, -1);
+    db = g_object_get_data (G_OBJECT (bookmarks), "db");
+    g_return_val_if_fail (db != NULL, -1);
+
+    g_assert(!strstr("parentid", condition));
+
+    id = folder ? katze_item_get_meta_integer (folder, "id") : 0;
+
+    if (id > 0)
+	sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
+				  "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
+				  id,
+				  condition);
+    else
+	sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
+				  "WHERE parentid IS NULL AND %s ",
+				  condition);
+
+    if (strstr (condition, "%q"))
+    {
+        sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
+        count = count_from_sqlite (db, sqlcmd_value);
+        sqlite3_free (sqlcmd_value);
+    }
+    else
+        count = count_from_sqlite (db, sqlcmd);
+
+    g_free (sqlcmd);
+
+    if (!recursive || (count < 0))
+        return count;
+
+    if (id > 0)
+	sqlcmd = g_strdup_printf ("parentid = %" G_GINT64_FORMAT " AND uri = ''",
+				  id);
+    else
+	sqlcmd = g_strdup ("parentid IS NULL AND uri = '' ");
+
+    array = midori_array_query_recursive (bookmarks, "id, uri", sqlcmd, NULL, NULL, FALSE);
+	     
+    g_free (sqlcmd);
+	    
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+	if (KATZE_ITEM_IS_FOLDER(item))
+	{
+	    gint64 sub_count = midori_array_count_recursive (bookmarks,
+							     condition,
+							     value,
+							     item,
+							     recursive);
+	     
+	    if (sub_count < 0)
+	    {
+		g_object_unref (array);
+		return -1;
+	    }
+	    
+	    count += sub_count;
+	}
+    }
+    
+    g_object_unref (array);
+    return count;
 }
 

=== modified file 'midori/midori-array.h'
--- midori/midori-array.h	2012-01-03 20:15:19 +0000
+++ midori/midori-array.h	2013-05-21 05:35:32 +0000
@@ -34,17 +34,26 @@
 midori_array_query     (KatzeArray*  array,
                         const gchar* fields,
                         const gchar* condition,
-                        const gchar* value);
+                        const gchar* value,
+			const gchar* order);
 
 KatzeArray*
 midori_array_query_recursive (KatzeArray*  array,
                               const gchar* fields,
                               const gchar* condition,
                               const gchar* value,
+                              const gchar* order,
                               gboolean     recursive);
 
 KatzeArray*
 katze_array_from_sqlite (sqlite3*     db,
                          const gchar* sqlcmd);
 
+gint64
+midori_array_count_recursive (KatzeArray*  bookmarks,
+			      const gchar* condition,
+                              const gchar* value,
+			      KatzeItem*   folder,
+                              gboolean     recursive);
+
 #endif /* !__MIDORI_ARRAY_H__ */

=== modified file 'midori/midori-bookmarks.c'
--- midori/midori-bookmarks.c	2012-11-25 15:37:41 +0000
+++ midori/midori-bookmarks.c	2013-05-21 05:35:32 +0000
@@ -25,6 +25,19 @@
     #include <unistd.h>
 #endif
 
+#define MIDORI_BOOKMARKS_DB_CONTROL(a) ((MidoriBookmarksDBControl*)(a)) 
+typedef struct _MidoriBookmarksDBControl MidoriBookmarksDBControl;
+struct _MidoriBookmarksDBControl
+{
+    sqlite3*    db;
+    GHashTable* pending_updates; 
+};
+
+static void
+midori_bookmarks_recursive_remove_childs_db (KatzeArray*  array,
+					     KatzeItem*  item,
+					     sqlite3*    db);
+
 void
 midori_bookmarks_dbtracer (void*       dummy,
                            const char* query)
@@ -32,31 +45,155 @@
     g_printerr ("%s\n", query);
 }
 
-void
+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 (gpointer data)
+{
+    MidoriBookmarksDBControl* control = MIDORI_BOOKMARKS_DB_CONTROL (data);
+    GHashTableIter hash_iter;
+    gpointer key, value;
+
+    g_hash_table_iter_init (&hash_iter, control->pending_updates);
+    
+    while (g_hash_table_iter_next (&hash_iter, &key, &value)) 
+    {
+	KatzeItem *item = KATZE_ITEM(key);
+	
+	midori_bookmarks_update_item_db (control->db, item);
+	g_object_unref (item);
+    }
+
+   g_hash_table_remove_all (control->pending_updates);
+
+   return FALSE;
+}
+
+static void
 midori_bookmarks_add_item_cb (KatzeArray* array,
                               KatzeItem*  item,
-                              sqlite3*    db)
+                              MidoriBookmarksDBControl* control)
 {
-    midori_bookmarks_insert_item_db (db, item,
+    midori_bookmarks_insert_item_db (control->db, item,
         katze_item_get_meta_integer (item, "parentid"));
 }
 
-void
+static void
+midori_bookmarks_update_item_cb (KatzeArray* array,
+				 KatzeItem*  item,
+				 MidoriBookmarksDBControl* control)
+{
+    if (!g_hash_table_size (control->pending_updates))
+	g_idle_add (midori_bookmarks_idle, control);
+    else if (g_hash_table_lookup (control->pending_updates, item))
+	return;
+    
+    g_object_ref (item);
+    g_hash_table_insert (control->pending_updates, item, item);
+}
+
+static void
 midori_bookmarks_remove_item_cb (KatzeArray* array,
                                  KatzeItem*  item,
-                                 sqlite3*    db)
+                                 MidoriBookmarksDBControl* control)
 {
     gchar* sqlcmd;
     char* errmsg = NULL;
-
+    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, control->pending_updates);
+    
+	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);
+	    }
+	}
+
+	midori_bookmarks_recursive_remove_childs_db (array, item, control->db);
+    }
+
+    if (found = g_hash_table_lookup (control->pending_updates, item))
+    {
+	g_hash_table_remove (control->pending_updates, found);
+	g_object_unref (found);
+    }
 
     sqlcmd = sqlite3_mprintf (
             "DELETE FROM bookmarks WHERE id = %" G_GINT64_FORMAT ";",
             katze_item_get_meta_integer (item, "id"));
 
+    if (sqlite3_exec (control->db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+    }
+
+    sqlite3_free (sqlcmd);
+}
+
+static void
+midori_bookmarks_recursive_remove_childs_db (KatzeArray*  array,
+					     KatzeItem*  item,
+					     sqlite3*    db)
+{
+    gint64 parentid = katze_item_get_meta_integer (item, "id");
+    char* errmsg = NULL;
+    KatzeArray* childs_array;
+    gchar* sqlcmd;
+ 
+    sqlcmd = g_strdup_printf ("SELECT id FROM bookmarks"
+                              "WHERE uri = '' AND parentid = %"G_GINT64_FORMAT ";",
+			      parentid);
+
+    childs_array = katze_array_from_sqlite (db, sqlcmd);
+    g_free (sqlcmd);
+
+    if (KATZE_IS_ARRAY (childs_array))
+    {
+	KatzeItem* child;
+	GList* list;
+
+	KATZE_ARRAY_FOREACH_ITEM_L (child, childs_array, list)
+	{
+	    katze_array_remove_item (array, child);
+	}
+
+	g_list_free (list);
+	g_object_unref(array);
+    }
+
+    sqlcmd = sqlite3_mprintf (
+            "DELETE FROM bookmarks WHERE parentid = %" G_GINT64_FORMAT ";",
+            parentid);
+
     if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
     {
-        g_printerr (_("Failed to remove history item: %s\n"), errmsg);
+        g_printerr (_("Failed to remove bookmarks folder child items: %s\n"), errmsg);
         sqlite3_free (errmsg);
     }
 
@@ -141,6 +278,7 @@
     gchar* sql_errmsg = NULL;
     gchar* import_errmsg = NULL;
     KatzeArray* array;
+    MidoriBookmarksDBControl* control;
 
     g_return_val_if_fail (errmsg != NULL, NULL);
 
@@ -279,12 +417,18 @@
     init_success:
         g_free (newfile);
         g_free (oldfile);
+        control = MIDORI_BOOKMARKS_DB_CONTROL (g_malloc (sizeof (*control)));
+        control->db = db;
+        control->pending_updates = g_hash_table_new (item_hash, item_equal);
         array = katze_array_new (KATZE_TYPE_ARRAY);
         g_signal_connect (array, "add-item",
-                          G_CALLBACK (midori_bookmarks_add_item_cb), db);
+                          G_CALLBACK (midori_bookmarks_add_item_cb), control);
+        g_signal_connect (array, "update-item",
+                          G_CALLBACK (midori_bookmarks_update_item_cb), control);
         g_signal_connect (array, "remove-item",
-                          G_CALLBACK (midori_bookmarks_remove_item_cb), db);
+                          G_CALLBACK (midori_bookmarks_remove_item_cb), control);
         g_object_set_data (G_OBJECT (array), "db", db);
+        g_object_set_data (G_OBJECT (array), "control", control);
         return array;
 
     init_failed:
@@ -323,5 +467,8 @@
     sqlite3* db = g_object_get_data (G_OBJECT (array), "db");
     g_return_if_fail (db != NULL);
     sqlite3_close (db);
+    MidoriBookmarksDBControl* control = g_object_get_data (G_OBJECT (array), "control");
+    g_return_if_fail (control != NULL);
+    g_hash_table_unref (control->pending_updates);
 }
 

=== modified file 'midori/midori-bookmarks.h'
--- midori/midori-bookmarks.h	2012-11-25 15:37:41 +0000
+++ midori/midori-bookmarks.h	2013-05-21 05:35:32 +0000
@@ -16,16 +16,6 @@
 #include <sqlite3.h>
 #include <katze/katze.h>
 
-void
-midori_bookmarks_add_item_cb (KatzeArray* array,
-                              KatzeItem*  item,
-                              sqlite3*    db);
-
-void
-midori_bookmarks_remove_item_cb (KatzeArray* array,
-                                 KatzeItem*  item,
-                                 sqlite3*    db);
-
 KatzeArray*
 midori_bookmarks_new (char** errmsg);
 

=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-05-19 09:33:02 +0000
+++ midori/midori-browser.c	2013-05-21 05:35:32 +0000
@@ -96,6 +96,8 @@
     gboolean show_statusbar;
     guint maximum_history_age;
     guint last_web_search;
+
+    gboolean bookmarkbar_populate;
 };
 
 G_DEFINE_TYPE (MidoriBrowser, midori_browser, GTK_TYPE_WINDOW)
@@ -166,16 +168,14 @@
                                   KatzeArray* array,
                                   gint64      parentid);
 
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-                                 KatzeItem* item);
-
 void
 midori_browser_open_bookmark (MidoriBrowser* browser,
                               KatzeItem*     item);
 
 static void
 midori_bookmarkbar_populate (MidoriBrowser* browser);
+static void
+midori_bookmarkbar_populate_idle (MidoriBrowser* browser);
 
 static void
 midori_bookmarkbar_clear (GtkWidget* toolbar);
@@ -484,6 +484,9 @@
         inter = ZEITGEIST_ZG_DELETE_EVENT;
     else
         g_assert_not_reached ();
+    g_assert (KATZE_IS_ITEM (item));
+    if (KATZE_ITEM_IS_FOLDER (item))
+	return;
     zeitgeist_log_insert_events_no_reply (zeitgeist_log_get_default (),
         zeitgeist_event_new_full (inter, ZEITGEIST_ZG_USER_ACTIVITY,
                                   "application://midori.desktop",
@@ -818,9 +821,8 @@
 
 static GtkWidget*
 midori_bookmark_folder_button_new (KatzeArray* array,
-                                   gboolean    new_bookmark,
                                    gint64      selected,
-                                   gint64      parentid)
+                                   gint64      new_parentid)
 {
     GtkListStore* model;
     GtkWidget* combo;
@@ -829,8 +831,16 @@
     sqlite3* db;
     sqlite3_stmt* statement;
     gint result;
-    const gchar* sqlcmd = "SELECT title, id FROM bookmarks WHERE uri='' ORDER BY title ASC";
+    const gchar* sqlcmd = "SELECT title, id, parentid FROM bookmarks WHERE uri='' ORDER BY parentid, title ASC";
+    guint selection;
+    gchar *parent_path;
+    gint64 parent_id;
 
+    /* folder combo box content:
+    ** 0: path
+    ** 1: path ellipsize mode
+    ** 2: id
+     */
     model = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT64);
     combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
     renderer = gtk_cell_renderer_text_new ();
@@ -838,31 +848,102 @@
     gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 0);
     gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "ellipsize", 1);
     gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
-        0, _("Bookmarks"), 1, PANGO_ELLIPSIZE_END, 2, (gint64)0, -1);
+        0, _("Bookmarks"), 1, PANGO_ELLIPSIZE_MIDDLE, 2, (gint64)0, -1);
     gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
 
     db = g_object_get_data (G_OBJECT (array), "db");
     g_return_val_if_fail (db != NULL, NULL);
+    selection = 0;
+    parent_id = -1;
+    parent_path = NULL;
     n = 1;
     if ((result = sqlite3_prepare_v2 (db, sqlcmd, -1, &statement, NULL)) == SQLITE_OK)
     while ((result = sqlite3_step (statement)) == SQLITE_ROW)
     {
-        const unsigned char* name = sqlite3_column_text (statement, 0);
+        const unsigned char* title = sqlite3_column_text (statement, 0);
         gint64 id = sqlite3_column_int64 (statement, 1);
+        gint64 parentid = sqlite3_column_int64 (statement, 2);
 
         /* do not show the folder itself */
         if (id != selected)
-        {
-            gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
-                0, name, 1, PANGO_ELLIPSIZE_END, 2, id, -1);
+	{
+            if (parentid != parent_id)
+            {
+                if (parent_path)
+                {  
+                    g_free(parent_path);
+                    parent_path = NULL;
+                    parent_id = -1;
+                }    
+		
+                if (!parentid)
+                {
+                    parent_id = 0;
+                    parent_path = g_strdup(_("Bookmarks"));
+                } 
+                else
+                {
+                    GtkTreeIter iter;
+                    gboolean valid;
+                    
+                    valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter);
+		    
+		    while (valid)
+		    {
+                        gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 
+                                            2, &parent_id, -1);
+                        
+                        if (parentid == parent_id)
+                        {
+                            gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 
+                                                0, &parent_path, -1);
+                            break;
+                        }
+			
+                        valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter);
+		    }
+                }
+            }
+	    
+            /* If something went wrong, fallback to title presentation */
+            if (parent_path)
+            {
+                gchar *path = g_strdup_printf ("%s/%s", parent_path, title);
+		
+                gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
+                                                   0, path ? path : (gchar*)title, 
+                                                   1, PANGO_ELLIPSIZE_MIDDLE, 
+                                                   2, id, -1);
+		
+                if (path)
+                    g_free (path);
+            }
+            else
+            {
+                gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
+                                                   0, title, 
+                                                   1, PANGO_ELLIPSIZE_MIDDLE, 
+                                                   2, id, -1);
+                parent_id = -1;
+            } 
+	    
+            if (id == new_parentid)
+                selection = n;
 
-            if (!new_bookmark && id == parentid)
-                gtk_combo_box_set_active (GTK_COMBO_BOX (combo), n);
             n++;
         }
     }
+
+    gtk_combo_box_set_active (GTK_COMBO_BOX (combo), selection);
+
     if (n < 2)
         gtk_widget_set_sensitive (combo, FALSE);
+    
+    if (parent_path)
+        g_free (parent_path);
+    
+    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE (model), 0, GTK_SORT_ASCENDING);
+
     return combo;
 }
 
@@ -876,14 +957,8 @@
 
     if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
     {
-        gchar* selected = NULL;
         GtkTreeModel* model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
-        gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 0, &selected, 2, &id, -1);
-
-        if (g_str_equal (selected, _("Bookmarks")))
-            id = 0;
-
-        g_free (selected);
+        gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 2, &id, -1);
     }
 
     return id;
@@ -910,11 +985,12 @@
 /* Private function, used by MidoriBookmarks and MidoriHistory */
 /* static */ gboolean
 midori_browser_edit_bookmark_dialog_new (MidoriBrowser* browser,
-                                         KatzeItem*     bookmark,
+                                         KatzeItem*     bookmark_or_parent,
                                          gboolean       new_bookmark,
                                          gboolean       is_folder,
                                          GtkWidget*     proxy)
 {
+    KatzeItem*   bookmark = bookmark_or_parent;
     const gchar* title;
     GtkWidget* dialog;
     GtkWidget* content_area;
@@ -980,7 +1056,7 @@
     gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
     gtk_container_set_border_width (GTK_CONTAINER (content_area), 5);
 
-    if (!bookmark)
+    if (new_bookmark)
     {
         view = midori_browser_get_current_tab (browser);
         if (is_folder)
@@ -993,6 +1069,12 @@
             bookmark = g_object_new (KATZE_TYPE_ITEM,
                 "uri", midori_view_get_display_uri (MIDORI_VIEW (view)),
                 "name", midori_view_get_display_title (MIDORI_VIEW (view)), NULL);
+
+	katze_item_set_meta_integer (
+	    bookmark, "parentid",
+	    (!bookmark_or_parent
+	     ? 0
+	     : katze_item_get_meta_integer (bookmark_or_parent, "id")));
     }
 
     entry_title = gtk_entry_new ();
@@ -1020,7 +1102,7 @@
     }
 
     combo_folder = midori_bookmark_folder_button_new (browser->bookmarks,
-        new_bookmark, katze_item_get_meta_integer (bookmark, "id"),
+        katze_item_get_meta_integer (bookmark, "id"),
         katze_item_get_meta_integer (bookmark, "parentid"));
     gtk_container_add (GTK_CONTAINER (content_area), combo_folder);
 
@@ -1054,7 +1136,7 @@
     {
         gint64 selected;
 
-        katze_item_set_name (bookmark,
+	katze_item_set_name (bookmark,
             gtk_entry_get_text (GTK_ENTRY (entry_title)));
         katze_item_set_meta_integer (bookmark, "toolbar",
             gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_toolbar)));
@@ -1072,16 +1154,11 @@
         if (new_bookmark)
             katze_array_add_item (browser->bookmarks, bookmark);
         else
-            midori_bookmarks_update_item_db (db, bookmark);
-        midori_browser_update_history (bookmark, "bookmark", new_bookmark ? "create" : "modify");
+            katze_array_update_item (browser->bookmarks, bookmark);
 
-        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_toolbar)))
-            if (!gtk_widget_get_visible (browser->bookmarkbar))
-                _action_set_active (browser, "Bookmarkbar", TRUE);
         return_status = TRUE;
     }
-    if (gtk_widget_get_visible (browser->bookmarkbar))
-        midori_bookmarkbar_populate (browser);
+
     gtk_widget_destroy (dialog);
     return return_status;
 }
@@ -3108,7 +3185,8 @@
         condition = "parentid = %q";
 
     bookmarks = midori_array_query (browser->bookmarks,
-        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id);
+        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, 
+	"pos_panel ASC,");
     if (!bookmarks)
         return FALSE;
 
@@ -4143,7 +4221,10 @@
     else if (!KATZE_IS_ARRAY (item) && strcmp (stock_id, GTK_STOCK_DELETE))
         gtk_widget_set_sensitive (menuitem, uri != NULL);
     g_object_set_data (G_OBJECT (menuitem), "KatzeItem", item);
-    g_signal_connect (menuitem, "activate", G_CALLBACK (callback), userdata);
+    if (callback)
+        g_signal_connect (menuitem, "activate", G_CALLBACK (callback), userdata);
+    else
+        gtk_widget_set_sensitive (menuitem, FALSE);
     gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
     gtk_widget_show (menuitem);
 }
@@ -4444,7 +4525,7 @@
     gtk_widget_show_all (hbox);
 
     combobox_folder = midori_bookmark_folder_button_new (browser->bookmarks,
-                                                         FALSE, 0, 0);
+                                                         0, 0);
     gtk_container_add (GTK_CONTAINER (content_area), combobox_folder);
 
     gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
@@ -4538,7 +4619,7 @@
 
     error = NULL;
     bookmarks = midori_array_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,
@@ -5963,6 +6044,21 @@
     }
 }
 
+static gboolean
+midori_browser_idle (gpointer data)
+{
+    MidoriBrowser* browser = MIDORI_BROWSER (data);
+
+    if (browser->bookmarkbar_populate)
+    {
+	midori_bookmarkbar_populate_idle (browser);
+
+	browser->bookmarkbar_populate = FALSE;
+    }
+
+    return FALSE;
+}
+
 static void
 midori_browser_init (MidoriBrowser* browser)
 {
@@ -6140,6 +6236,8 @@
         "array", dummy_array /* updated, unique */,
         NULL);
     g_object_connect (action,
+                      "signal::populate-folder",
+                      _action_bookmarks_populate_folder, browser,
                       "signal::populate-popup",
                       _action_tools_populate_popup, browser,
                       "signal::activate-item-alt",
@@ -6443,6 +6541,8 @@
     katze_object_assign (browser->history, NULL);
     katze_object_assign (browser->dial, NULL);
 
+    g_idle_remove_by_data (browser);
+
     G_OBJECT_CLASS (midori_browser_parent_class)->finalize (object);
 }
 
@@ -6978,6 +7078,30 @@
 }
 
 static void
+midori_bookmarkbar_add_item_cb (KatzeArray*    bookmarks,
+				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);
+    midori_browser_update_history (item, "bookmark", "created");
+}
+
+static void
+midori_bookmarkbar_update_item_cb (KatzeArray*    bookmarks,
+                                   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);
+    midori_browser_update_history (item, "bookmark", "modify");
+}
+
+static void
 midori_bookmarkbar_remove_item_cb (KatzeArray*    bookmarks,
                                    KatzeItem*     item,
                                    MidoriBrowser* browser)
@@ -6990,6 +7114,16 @@
 static void
 midori_bookmarkbar_populate (MidoriBrowser* browser)
 {
+    if (browser->bookmarkbar_populate)
+	return;
+    
+    g_idle_add (midori_browser_idle, browser);
+    browser->bookmarkbar_populate = TRUE;
+}
+
+static void
+midori_bookmarkbar_populate_idle (MidoriBrowser* browser)
+{
     KatzeArray* array;
     KatzeItem* item;
 
@@ -7000,7 +7134,7 @@
                         gtk_separator_tool_item_new (), -1);
 
     array = midori_array_query (browser->bookmarks,
-        "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL);
+	"id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, "pos_bar ASC,");
     if (!array)
     {
         _action_set_sensitive (browser, "BookmarkAdd", FALSE);
@@ -7016,9 +7150,12 @@
         {
             gint64 id = katze_item_get_meta_integer (item, "id");
             gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT, id);
-            KatzeArray* subfolder = midori_array_query (browser->bookmarks,
-                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q AND uri != ''",
-                parentid);
+            KatzeArray* subfolder = midori_array_query (
+		browser->bookmarks,
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", 
+		"parentid = %q",
+                parentid,
+		"pos_panel ASC,");
 
                 katze_item_set_name (KATZE_ITEM (subfolder), katze_item_get_name (item));
                 katze_item_set_meta_integer (KATZE_ITEM (subfolder), "id", id);
@@ -7059,8 +7196,15 @@
     MidoriWebSettings* settings;
 
     if (browser->bookmarks != NULL)
+    {
+        g_signal_handlers_disconnect_by_func (browser->bookmarks,
+            midori_bookmarkbar_add_item_cb, browser);
+        g_signal_handlers_disconnect_by_func (browser->bookmarks,
+            midori_bookmarkbar_update_item_cb, browser);
         g_signal_handlers_disconnect_by_func (browser->bookmarks,
             midori_bookmarkbar_remove_item_cb, browser);
+    }
+    
     settings = midori_browser_get_settings (browser);
     g_signal_handlers_disconnect_by_func (settings,
         midori_browser_show_bookmarkbar_notify_value_cb, browser);
@@ -7089,6 +7233,10 @@
     g_signal_connect (settings, "notify::show-bookmarkbar",
         G_CALLBACK (midori_browser_show_bookmarkbar_notify_value_cb), browser);
     g_object_notify (G_OBJECT (settings), "show-bookmarkbar");
+    g_signal_connect_after (bookmarks, "add-item",
+        G_CALLBACK (midori_bookmarkbar_add_item_cb), browser);
+    g_signal_connect_after (bookmarks, "update-item",
+        G_CALLBACK (midori_bookmarkbar_update_item_cb), browser);
     g_signal_connect_after (bookmarks, "remove-item",
         G_CALLBACK (midori_bookmarkbar_remove_item_cb), browser);
 }

=== modified file 'midori/midori-view.c'
--- midori/midori-view.c	2013-05-08 00:51:02 +0000
+++ midori/midori-view.c	2013-05-21 05:35:32 +0000
@@ -2759,7 +2759,7 @@
             _("Open Link in New _Window"), STOCK_WINDOW_NEW,
             G_CALLBACK (midori_web_view_menu_new_window_activate_cb), widget);
         midori_view_insert_menu_item (menu_shell, -1,
-            _("Open Link as Web A_pplication"), NULL,
+            _("Open Link as Web A_pplication"), GTK_STOCK_EXECUTE,
             G_CALLBACK (midori_web_view_menu_web_app_activate_cb), widget);
         }
 

=== modified file 'panels/midori-bookmarks.c'
--- panels/midori-bookmarks.c	2013-02-11 21:49:41 +0000
+++ panels/midori-bookmarks.c	2013-05-21 05:35:32 +0000
@@ -25,6 +25,150 @@
 
 #define COMPLETION_DELAY 200
 
+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 *source_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->source_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,
@@ -36,6 +180,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;
@@ -49,6 +199,16 @@
 
     gint filter_timeout;
     gchar* filter;
+
+    struct _stock_pending_event
+    {
+        gint x;
+        gint y;
+    } *pending_event,
+        stock_pending_event;
+	
+    GHashTable* updated_items;
+    GList* added_paths;
 };
 
 struct _MidoriBookmarksClass
@@ -86,6 +246,49 @@
                                GParamSpec* pspec);
 
 static void
+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);
+static void
+midori_bookmarks_remove_item_cb (KatzeArray*      array,
+                                 KatzeItem*       item,
+                                 MidoriBookmarks* bookmarks);
+
+static void
+midori_bookmarks_row_added_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_idle_remove_item (MidoriBookmarks* bookmarks, KatzeItem *item);
+
+static gboolean
+midori_bookmarks_idle (gpointer data);
+
+static void
 midori_bookmarks_class_init (MidoriBookmarksClass* class)
 {
     GObjectClass* gobject_class;
@@ -133,7 +336,7 @@
     gchar* parent_id;
 
     parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    if (!(root_array = midori_array_query (array, "*", "parentid = %q", parent_id)))
+    if (!(root_array = midori_array_query (array, "*", "parentid = %q", parent_id, "pos_pnel DESC,")))
     {
         g_free (parent_id);
         return;
@@ -186,20 +389,20 @@
 
     if (keyword && *keyword)
         array = midori_array_query (bookmarks->array,
-           "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword);
+				    "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, NULL);
     else
     {
         if (parentid > 0)
         {
             gchar* parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
             array = midori_array_query (bookmarks->array,
-               "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id);
+		"id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, "pos_panel DESC,");
 
             g_free (parent_id);
         }
         else
             array = midori_array_query (bookmarks->array,
-               "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL);
+               "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, "pos_panel DESC,");
     }
     return array ? array : katze_array_new (KATZE_TYPE_ITEM);
 }
@@ -216,19 +419,39 @@
     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);
+
+ }
 
 gint64
 midori_bookmarks_insert_item_db (sqlite3*   db,
@@ -316,16 +539,237 @@
     return seq;
 }
 
+static gboolean
+midori_bookmarks_reach_item_recurse (GtkTreeModel* model,
+                                     GtkTreeIter* iter,
+                                     gint64 id)
+{
+    do
+    {
+        GtkTreeIter child;
+        KatzeItem *item;
+        gint64 itemid = -1;
+
+        gtk_tree_model_get (model, iter, 0, &item, -1);
+
+        if (!KATZE_ITEM_IS_SEPARATOR(item))
+        {
+            itemid = katze_item_get_meta_integer (item, "id");
+            g_object_unref (item);
+        }
+
+        if (id == itemid)
+            return TRUE;
+
+        if (gtk_tree_model_iter_children (model, &child, iter))
+        {
+            if (midori_bookmarks_reach_item_recurse (model, &child, id))
+            {
+                *iter = child;
+                return TRUE;
+            }
+        }
+    }
+    while (gtk_tree_model_iter_next(model, iter));
+
+    return FALSE;
+}
+
+static gboolean
+midori_bookmarks_reach_item (GtkTreeModel* model,
+                             GtkTreeIter* iter,
+                             gint64 id)
+{
+    if (!gtk_tree_model_get_iter_first(model, iter))
+        return FALSE;
+
+    return midori_bookmarks_reach_item_recurse (model, iter, id);
+}
+
+static void
+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 (tree_store, NULL, parent,
+                                           position,
+                                           0, item, 1, tooltip, -1);
+        g_free (tooltip);
+    }
+    else if (KATZE_ITEM_IS_FOLDER (item))
+    {
+        GtkTreeIter root_iter;
+
+        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 (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)
+{
+    g_signal_handlers_block_by_func (model,
+                                     midori_bookmarks_row_changed_cb,
+                                     bookmarks);
+
+    if (KATZE_ITEM_IS_BOOKMARK (item))
+    {
+        gchar* tooltip = g_markup_escape_text (katze_item_get_uri (item), -1);
+
+        gtk_tree_store_set(model, iter,
+                           0, item, 1, tooltip, -1);
+
+        g_free (tooltip);
+    }
+    else
+    {
+        gtk_tree_store_set(model, iter,
+                           0, item, -1);
+    }
+
+    g_signal_handlers_unblock_by_func (model,
+                                       midori_bookmarks_row_changed_cb,
+                                       bookmarks);
+
+}
+
 static void
 midori_bookmarks_add_item_cb (KatzeArray*      array,
                               KatzeItem*       item,
                               MidoriBookmarks* bookmarks)
 {
-    GtkTreeModel* model;
-    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);
+    GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
+    GtkTreeIter iter;
+    gint64 parentid;
+
+    g_assert (KATZE_IS_ITEM (item));
+
+    parentid = katze_item_get_meta_integer (item, "parentid");
+
+    if (!parentid)
+        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)
+	    || !n_children)
+	    midori_bookmarks_add_item_to_model (bookmarks, model, &iter, item);
+
+        gtk_tree_path_free (path);
+    }
+}
+
+static void
+midori_bookmarks_update_item_cb (KatzeArray*      array,
+                                 KatzeItem*       item,
+                                 MidoriBookmarks* bookmarks)
+{
+    gint64 id = katze_item_get_meta_integer (item, "id");
+    gint64 parentid = katze_item_get_meta_integer (item, "parentid");
+    GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
+    GtkTreeIter iter;
+
+    g_assert (KATZE_IS_ITEM (item));
+
+    if (midori_bookmarks_reach_item (model, &iter, id))
+    {
+        gint64 old_parentid = 0;
+        GtkTreeIter parent;
+
+        if (gtk_tree_model_iter_parent (model, &parent, &iter))
+        {
+            KatzeItem* old_parent;
+
+            gtk_tree_model_get (model, &parent, 0, &old_parent, -1);
+
+            old_parentid = katze_item_get_meta_integer (old_parent, "id");
+
+            g_object_unref (old_parent);
+
+            if (parentid == old_parentid)
+            {
+                midori_bookmarks_update_item_in_model (bookmarks, GTK_TREE_STORE (model), &iter, item);
+            }
+            else
+            {
+                gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+
+                if (!gtk_tree_model_iter_has_child (model, &parent))
+                {
+                    GtkTreePath* path = gtk_tree_model_get_path(model, &parent);
+
+                    if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
+                        gtk_tree_view_collapse_row (GTK_TREE_VIEW (bookmarks->treeview), path);
+
+                    gtk_tree_path_free (path);
+                }
+
+                midori_bookmarks_add_item_cb (array, item, bookmarks);
+            }
+        }
+        else if (parentid == 0)
+        {
+            midori_bookmarks_update_item_in_model (bookmarks, GTK_TREE_STORE (model), &iter, item);
+        }
+        else
+        {
+            gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+
+            midori_bookmarks_add_item_cb (array, item, bookmarks);
+        }
+    }
+    else
+        midori_bookmarks_add_item_cb (array, item, bookmarks);
 }
 
 static void
@@ -333,22 +777,665 @@
                                  KatzeItem*       item,
                                  MidoriBookmarks* bookmarks)
 {
+    gint64 id = katze_item_get_meta_integer (item, "id");
     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);
+    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;
+
+        if (gtk_tree_model_iter_parent (model, &parent, &iter))
+        {
+            gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+
+            if (!gtk_tree_model_iter_has_child (model, &parent))
+            {
+                GtkTreePath* path = gtk_tree_model_get_path(model, &parent);
+
+                if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
+                    gtk_tree_view_collapse_row (GTK_TREE_VIEW (bookmarks->treeview), path);
+
+                gtk_tree_path_free (path);
+            }
+        }
+        else
+        {
+            gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
+        }
+
+        midori_bookmarks_statusbar_update (bookmarks);
+    }
 }
 
+
 static void
 midori_bookmarks_update_cb (KatzeArray*      array,
                             MidoriBookmarks* bookmarks)
 {
     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);
-}
-
+
+    midori_bookmarks_statusbar_update (bookmarks);
+}
+
+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 ("GTK_TREE_MODEL_MULTI_ROWS"),
+                            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 ("GTK_TREE_MODEL_MULTI_ROWS"))
+    {
+        GtkTreeModel *model;
+        GList* rows;
+        if (katze_tree_view_get_selected_rows (
+            tree_store->source_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 void
+update_path_list_for_delete (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)  /* removal was donne in a deeper branch than source */
+	    continue;
+	
+	if (ia[la-1] > ib[la-1]) /* removal was donne after source */
+	    continue;
+	
+	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 */
+	    continue;
+	
+	/* source at depth level of removal must be decremented due to the removal */
+	ib[la-1] -= 1;
+    }
+}
+
+static gboolean
+midori_bookmarks_tree_store_drag_data_delete (GtkTreeDragSource*  drag_source,
+                                              GtkTreePath*      source_path)
+{
+    gboolean status = TRUE;
+    guint length;
+    guint i;
+    MidoriBookmarksTreeStore *tree_store = MIDORI_BOOKMARKS_TREE_STORE(drag_source);
+    GtkTreeModel* model = GTK_TREE_MODEL(drag_source);
+
+    if (!tree_store->stock_got_rows)
+        return TRUE;
+
+    length = g_list_length (tree_store->stock_got_rows);
+    for (i = 0; i < length; i++)
+    {
+        GtkTreePath *prev = (GtkTreePath *)g_list_nth_data (tree_store->stock_got_rows, i);
+        GtkTreeIter iter;
+
+        if (gtk_tree_model_get_iter (model, &iter, prev))
+        {
+            gint j;
+            gchar* src_path_str = gtk_tree_path_to_string (prev);
+
+            /* remove item updating source paths */
+            g_free(src_path_str);
+
+            gtk_tree_store_remove (GTK_TREE_STORE (drag_source), &iter);
+
+	    update_path_list_for_delete (tree_store->stock_got_rows, prev);
+        }
+        else
+            status = FALSE;
+    }
+
+    g_list_free_full (tree_store->stock_got_rows, (GDestroyNotify) gtk_tree_path_free);
+    tree_store->stock_got_rows = NULL;
+
+    return status;
+}
+
+static gboolean
+midori_bookmarks_tree_store_get_rows_drag_data (GtkSelectionData  *selection_data,
+                                                GtkTreeModel     **tree_model,
+                                                GList     **rows)
+{
+    GList *list;
+    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 ("GTK_TREE_MODEL_MULTI_ROWS"))
+        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;
+}
+
+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);
+    GtkTreeIter dest_parent;
+    GtkTreePath *parent = gtk_tree_path_copy (dest_path);
+    GtkTreeIter *dest_parent_p = NULL;
+    gboolean row_drop_possible = TRUE;
+
+    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);
+
+    if (dest_parent_p)
+    {
+        KatzeItem* item;
+
+        gtk_tree_model_get (dest_model, dest_parent_p, 0, &item, -1);
+
+        if (!KATZE_ITEM_IS_FOLDER(item))
+            row_drop_possible = FALSE;
+
+        if (item)
+            g_object_unref (item);
+    }
+
+    if (!row_drop_possible)
+        return FALSE;
+
+    if (gtk_selection_data_get_target (selection_data) ==
+	gdk_atom_intern_static_string ("GTK_TREE_MODEL_MULTI_ROWS"))
+    {
+        GtkTreeModel *model;
+        GList* rows;
+
+        if (midori_bookmarks_tree_store_get_rows_drag_data (selection_data,
+                                                            &model,
+                                                            &rows))
+        {
+          /* TODO: */
+	  /*   if (destination_is_in_folders (GTK_TREE_MODEL(drag_dest), dest_path) */
+	  /* 	&& selection_contains_bookmarks (mode, rows)) */
+	  /*   { */
+	  /* 	row_drop_possible = FALSE; */
+	  /* 	goto done; */
+	  /*   } */
+	  /*   if (destination_is_in_bookmarks (GTK_TREE_MODEL(drag_dest), dest_path) */
+	  /* 	&& selection_contains_folders (mode, rows)) */
+	  /*   { */
+	  /* 	row_drop_possible = FALSE; */
+	  /* 	goto done; */
+	  /*   } */
+            if (model == GTK_TREE_MODEL(drag_dest))
+            {
+                gint length = g_list_length (rows);
+                gint i;
+
+                for (i = 0; i < length; i++)
+                {
+                    gint j;
+                    GtkTreePath *src_path = (GtkTreePath *)g_list_nth_data (rows, i);
+
+                    /* Can't drop into ourself. */
+                    if (gtk_tree_path_is_ancestor (src_path,
+                                                   dest_path))
+		    {
+                        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
+            return FALSE;
+    }
+    else
+        return FALSE;
+
+    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 ("GTK_TREE_MODEL_MULTI_ROWS"))
+    {
+        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++)
+            {
+                gint j;
+                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
+midori_bookmarks_row_added_cb (GtkTreeModel*    model,
+			       GtkTreePath*     path,
+			       GtkTreeIter*     iter,
+			       MidoriBookmarks* bookmarks)
+{
+    if (!g_hash_table_size (bookmarks->updated_items)
+	|| (!g_list_length (bookmarks->added_paths)))
+	g_idle_add (midori_bookmarks_idle, bookmarks);
+
+    update_path_list_for_insert (bookmarks->added_paths, path);
+
+    bookmarks->added_paths = g_list_append (bookmarks->added_paths, gtk_tree_path_copy (path));
+}
+
+static void
+update_items_for_parent (GtkTreeModel*    model,
+			 GtkTreePath*     path,
+			 MidoriBookmarks* bookmarks)
+{
+    if ((gtk_tree_path_get_depth (path) > 1)
+	&& gtk_tree_path_up (path))
+    {
+	KatzeItem *item;
+	GtkTreeIter parent;
+	GtkTreeIter local_iter;
+	gint64 id;
+	
+	if (!gtk_tree_model_get_iter (model, &parent, path))
+	    return;
+	
+	gtk_tree_model_get (model, &parent, 0, &item, -1);
+	
+	g_assert (KATZE_ITEM_IS_FOLDER (item));
+	
+	id = katze_item_get_meta_integer (item, "id");
+	
+	g_object_unref (item);
+	
+	if (gtk_tree_model_iter_children (model, &local_iter, &parent))
+	    midori_bookmarks_set_item_positon(model, &local_iter, id, bookmarks);
+    }
+    else
+    {
+	GtkTreeIter local_iter;
+	if (gtk_tree_model_get_iter_first (model, &local_iter))
+	    midori_bookmarks_set_item_positon(model, &local_iter, 0, bookmarks);
+    }
+}
+
+static void
+midori_bookmarks_row_deleted_cb (GtkTreeModel*    model,
+				 GtkTreePath*     path,
+				 MidoriBookmarks* bookmarks)
+{
+    GList* found;
+
+    if (!g_hash_table_size (bookmarks->updated_items)
+	|| (!g_list_length (bookmarks->added_paths)))
+	g_idle_add (midori_bookmarks_idle, bookmarks);
+
+    while (found = g_list_find_custom (bookmarks->added_paths, 
+				       path, (GCompareFunc)gtk_tree_path_compare))
+    {
+	bookmarks->added_paths = g_list_remove(bookmarks->added_paths, found->data);
+	gtk_tree_path_free ((GtkTreePath*)found->data);
+    }
+
+    update_path_list_for_delete (bookmarks->added_paths, path);
+    update_items_for_parent (model, path, bookmarks);
+}
 
 static void
 midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
@@ -356,44 +1443,59 @@
                                  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_array_remove_item (bookmarks->array, item);
-    katze_item_set_meta_integer (item, "parentid", parentid);
-    katze_array_add_item (bookmarks->array, item);
-
-    g_object_unref (item);
-    if (new_parent)
-        g_object_unref (new_parent);
+    update_items_for_parent (model, path, bookmarks);
 }
 
 static void
-midori_bookmarks_add_clicked_cb (GtkWidget* toolitem)
+midori_bookmarks_add_clicked_cb (GtkWidget* toolitem,
+				 MidoriBookmarks* bookmarks)
 {
     MidoriBrowser* browser = midori_browser_get_for_widget (toolitem);
-    /* FIXME: Take selected folder into account */
+    GtkTreeView* treeview = GTK_TREE_VIEW (bookmarks->treeview);
+    GtkTreeModel* model;
+    GtkTreeIter iter;
+    KatzeItem* parent = NULL;
+
+    if (katze_tree_view_get_selected_iter (treeview,
+                                           &model, &iter))
+    {
+	gboolean done = FALSE;
+	while (!done)
+	{
+	    gtk_tree_model_get (model, &iter, 0, &parent, -1);
+	
+	    if (KATZE_ITEM_IS_FOLDER (parent))
+	    {
+		GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
+
+		if (!gtk_tree_view_row_expanded (treeview, path))
+		    gtk_tree_view_expand_row (treeview, path, FALSE);
+        
+		gtk_tree_path_free (path);
+		done = TRUE;
+	    }
+	    else
+	    {
+		GtkTreeIter child = iter;
+
+		if (parent) g_object_unref (parent);
+		parent = NULL;
+
+		if (!gtk_tree_model_iter_parent (model, &iter, &child))
+		{
+		    done = TRUE;
+		}
+	    }
+	}
+    }
+    
     if (g_str_equal (gtk_widget_get_name (toolitem), "BookmarkFolderAdd"))
-        midori_browser_edit_bookmark_dialog_new (browser, NULL, TRUE, TRUE, toolitem);
+        midori_browser_edit_bookmark_dialog_new (browser, parent, TRUE, TRUE, toolitem);
     else
-        midori_browser_edit_bookmark_dialog_new (browser, NULL, TRUE, FALSE, toolitem);
+        midori_browser_edit_bookmark_dialog_new (browser, parent, TRUE, FALSE, toolitem);
+
+    if (parent)
+	g_object_unref (parent);
 }
 
 static void
@@ -408,24 +1510,15 @@
     {
         KatzeItem* item;
         MidoriBrowser* browser;
-        gint64 parentid;
 
         gtk_tree_model_get (model, &iter, 0, &item, -1);
 
         g_assert (!KATZE_ITEM_IS_SEPARATOR (item));
 
         browser = midori_browser_get_for_widget (bookmarks->treeview);
-        parentid = katze_item_get_meta_integer (item, "parentid");
         midori_browser_edit_bookmark_dialog_new (
             browser, item, FALSE, KATZE_ITEM_IS_FOLDER (item), NULL);
 
-        if (katze_item_get_meta_integer (item, "parentid") != parentid)
-        {
-            gtk_tree_store_clear (GTK_TREE_STORE (model));
-            midori_bookmarks_read_from_db_to_model (bookmarks, GTK_TREE_STORE (model),
-                    NULL, 0, NULL);
-        }
-
         g_object_unref (item);
     }
 }
@@ -433,12 +1526,226 @@
 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 void
+midori_bookmarks_statusbar_update (MidoriBookmarks *bookmarks)
+{
+    gchar* text = NULL;
+    GtkTreeModel* model;
+    GList   *rows;
+    gint selected;
+
+    selected = katze_tree_view_get_selected_rows (
+        GTK_TREE_VIEW (bookmarks->treeview), &model, &rows);
+
+    if (selected == 1)
+    {
+	GtkTreePath* path = (GtkTreePath *)g_list_nth_data (rows, 0);
+	GtkTreeIter iter;
+        KatzeItem* item;
+        const gchar* name;
+
+	if (!gtk_tree_model_get_iter (model, &iter, path))
+	    return;
+
+        gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+        g_assert (!KATZE_ITEM_IS_SEPARATOR (item));
+
+        name = katze_item_get_name (item);
+
+        if (KATZE_ITEM_IS_FOLDER (item))
+        {
+            gint child_folders_count = midori_array_count_recursive(
+		bookmarks->array,
+		"uri = ''",
+		NULL,
+		item,
+		FALSE);
+            gint child_bookmarks_count = midori_array_count_recursive(
+		bookmarks->array,
+		"uri <> ''",
+		NULL,
+		item,
+		FALSE);
+
+            if (!child_bookmarks_count && !child_folders_count)
+                text = g_strdup_printf(
+                    _("%s : empty folder"),
+                    name);
+            else if (!child_bookmarks_count && (child_folders_count == 1))
+                text = g_strdup_printf(
+                    _("%s : folder, one subfolder and no bookmark"),
+                    name);
+            else if (!child_bookmarks_count && child_folders_count)
+                text = g_strdup_printf(
+                    _("%s : folder, %d subfolders and no bookmark"),
+                    name, child_folders_count);
+            else if ((child_bookmarks_count == 1) && !child_folders_count)
+                text = g_strdup_printf(
+                    _("%s : folder, one bookmark"),
+                    name);
+            else if ((child_bookmarks_count == 1) && (child_folders_count == 1))
+                text = g_strdup_printf(
+                    _("%s : folder, one bookmark and one subfolder"),
+                    name);
+            else if ((child_bookmarks_count == 1) && child_folders_count)
+                text = g_strdup_printf(
+                    _("%s : folder, one bookmark and %d subfolders"),
+                    name, child_folders_count);
+            else if (child_bookmarks_count && !child_folders_count)
+                text = g_strdup_printf(
+                    _("%s : folder, %d bookmarks"),
+                    name, child_bookmarks_count);
+            else if (child_bookmarks_count && (child_folders_count == 1))
+                text = g_strdup_printf(
+                    _("%s : folder, %d bookmarks and one subfolder"),
+                    name, child_bookmarks_count);
+            else if (child_bookmarks_count && child_folders_count)
+                text = g_strdup_printf(
+                    _("%s : folder, %d bookmarks and %d subfolders"),
+                    name, child_bookmarks_count, child_folders_count);
+        }
+        else if (KATZE_ITEM_IS_BOOKMARK (item))
+        {
+            const gchar* uri = katze_item_get_uri (item);
+
+	    if (katze_item_get_meta_boolean (item, "app"))
+		text = g_strdup_printf (_("%s : web application bookmark to : %s"), name, uri);
+	    else
+		text = g_strdup_printf (_("%s : bookmark to : %s"), name, uri);
+        }
+
+	g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+    }
+    else if (selected > 1)
+    {
+        gint i;
+        gint selected_folders_count = 0;
+        gint selected_bookmarks_count = 0;
+
+        for (i = 0 ; i < selected ; i++)
+        {
+            GtkTreeIter iter;
+            KatzeItem* item;
+
+            g_return_if_fail (gtk_tree_model_get_iter (
+                                  model, &iter, (GtkTreePath *)g_list_nth_data (rows, i)));
+
+            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++;
+            }
+        }
+
+        if (!selected_bookmarks_count && !selected_folders_count)
+            g_assert_not_reached ();
+        else if (!selected_bookmarks_count && (selected_folders_count == 1))
+            text = g_strdup_printf(
+                _("one folder and no bookmark selected"));
+        else if (!selected_bookmarks_count && selected_folders_count)
+            text = g_strdup_printf(
+                _("%d folders and no bookmark selected"),
+                selected_folders_count);
+        else if ((selected_bookmarks_count == 1) && !selected_folders_count)
+            text = g_strdup_printf(
+                _("one bookmark selected"));
+        else if ((selected_bookmarks_count == 1) && (selected_folders_count == 1))
+            text = g_strdup_printf(
+                _("one bookmark and one folder selected"));
+        else if ((selected_bookmarks_count == 1) && selected_folders_count)
+            text = g_strdup_printf(
+                _("one bookmark and %d folders selected"),
+                selected_folders_count);
+        else if (selected_bookmarks_count && !selected_folders_count)
+            text = g_strdup_printf(
+                _("%d bookmarks selected"),
+                selected_bookmarks_count);
+        else if (selected_bookmarks_count && (selected_folders_count == 1))
+            text = g_strdup_printf(
+                _("%d bookmarks and one folder selected"),
+                selected_bookmarks_count);
+        else if (selected_bookmarks_count && selected_folders_count)
+            text = g_strdup_printf(
+                _("%d bookmarks and %d folders selected"),
+                selected_bookmarks_count, selected_folders_count);
+
+        g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+    }
+    else
+    {
+	gint child_folders_count = midori_array_count_recursive(
+	    bookmarks->array,
+	    "uri = ''",
+	    NULL,
+	    NULL,
+	    FALSE);
+	gint child_bookmarks_count = midori_array_count_recursive(
+	    bookmarks->array,
+	    "uri <> ''",
+	    NULL,
+	    NULL,
+	    FALSE);
+	
+	if (!child_bookmarks_count && !child_folders_count)
+	    text = g_strdup_printf(
+		_("Bookmarks : empty"));
+	else if (!child_bookmarks_count && (child_folders_count == 1))
+	    text = g_strdup_printf(
+		_("Bookmarks : one folder and no bookmark"));
+	else if (!child_bookmarks_count && child_folders_count)
+	    text = g_strdup_printf(
+		_("Bookmarks : %d folders and no bookmark"),
+		child_folders_count);
+	else if ((child_bookmarks_count == 1) && !child_folders_count)
+	    text = g_strdup_printf(
+		_("Bookmarks : one bookmark"));
+	else if ((child_bookmarks_count == 1) && (child_folders_count == 1))
+	    text = g_strdup_printf(
+		_("Bookmarks : one bookmark and one folder"));
+	else if ((child_bookmarks_count == 1) && child_folders_count)
+	    text = g_strdup_printf(
+		_("Bookmarks : one bookmark and %d folders"),
+		child_folders_count);
+	else if (child_bookmarks_count && !child_folders_count)
+	    text = g_strdup_printf(
+		_("Bookmarks : %d bookmarks"),
+		child_bookmarks_count);
+	else if (child_bookmarks_count && (child_folders_count == 1))
+	    text = g_strdup_printf(
+		_("Bookmarks : %d bookmarks and one folder"),
+		child_bookmarks_count);
+	else if (child_bookmarks_count && child_folders_count)
+	    text = g_strdup_printf(
+		_("Bookmarks : %d bookmarks and %d folders"),
+		child_bookmarks_count, child_folders_count);
+    }
+
+    if (text)
+    {
+        MidoriBrowser* browser = midori_browser_get_for_widget (bookmarks->treeview);
+
+        g_object_set (browser, "statusbar-text", text, NULL);
+
+        g_free(text);
+    }
 }
 
 gboolean
@@ -458,7 +1765,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_panel=%" G_GINT64_FORMAT ", pos_bar=%" G_GINT64_FORMAT " "
             "WHERE id = %" G_GINT64_FORMAT ";",
             parentid,
             katze_item_get_name (item),
@@ -466,8 +1774,14 @@
             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"),
+            katze_item_get_meta_integer (item, "pos_panel"),
+            katze_item_get_meta_integer (item, "pos_bar"),
             katze_item_get_meta_integer (item, "id"));
 
+    /* g_printf("update: %d -> %d\n",  */
+    /* 	     (gint)katze_item_get_meta_integer (item, "id"), */
+    /* 	     (gint)katze_item_get_meta_integer (item, "pos_panel")); */
+
     updated = TRUE;
     if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
     {
@@ -487,23 +1801,38 @@
                                     MidoriBookmarks* bookmarks)
 {
     GtkTreeModel* model;
-    GtkTreeIter iter;
+    GList* rows;
+    gint length;
 
-    if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (bookmarks->treeview),
-                                           &model, &iter))
+    length = katze_tree_view_get_selected_rows(GTK_TREE_VIEW (bookmarks->treeview),
+                                               &model, &rows);
+    while (length)
     {
-        KatzeItem* item;
-
-        gtk_tree_model_get (model, &iter, 0, &item, -1);
-
-        /* Manually remove the iter and block clearing the treeview */
-        gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
-        g_signal_handlers_block_by_func (bookmarks->array,
-            midori_bookmarks_remove_item_cb, bookmarks);
-        katze_array_remove_item (bookmarks->array, item);
-        g_signal_handlers_unblock_by_func (bookmarks->array,
-            midori_bookmarks_remove_item_cb, bookmarks);
-        g_object_unref (item);
+        gint new_length;
+        GtkTreeIter iter;
+
+        if (gtk_tree_model_get_iter (
+                model, &iter, (GtkTreePath *)g_list_nth_data (rows, 0)))
+        {
+            KatzeItem* item;
+
+            gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+            if (KATZE_IS_ITEM(item))
+            {
+                katze_array_remove_item (bookmarks->array, item);
+            }
+
+            g_object_unref (item);
+        }
+
+        g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+
+        new_length = katze_tree_view_get_selected_rows(GTK_TREE_VIEW (bookmarks->treeview),
+                                                       &model, &rows);
+
+        /* avoid infinite loop due to delete failure */
+        length = (new_length == length) ? 0 : new_length;
     }
 }
 
@@ -547,6 +1876,7 @@
         gtk_widget_show (GTK_WIDGET (toolitem));
         bookmarks->delete = GTK_WIDGET (toolitem);
         midori_bookmarks_toolbar_update (bookmarks);
+        midori_bookmarks_statusbar_update (bookmarks);
         toolitem = gtk_separator_tool_item_new ();
         gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE);
         gtk_tool_item_set_expand (toolitem, TRUE);
@@ -599,10 +1929,18 @@
     midori_bookmarks_read_from_db_to_model (bookmarks, GTK_TREE_STORE (model), NULL, 0, NULL);
     g_signal_connect_after (bookmarks->array, "add-item",
                       G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
+    g_signal_connect_after (bookmarks->array, "update-item",
+                      G_CALLBACK (midori_bookmarks_update_item_cb), bookmarks);
     g_signal_connect (bookmarks->array, "remove-item",
                       G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
     g_signal_connect (bookmarks->array, "update",
                       G_CALLBACK (midori_bookmarks_update_cb), bookmarks);
+    g_signal_connect_after (model, "row-inserted",
+                            G_CALLBACK (midori_bookmarks_row_added_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);
@@ -745,7 +2083,10 @@
     else if (!KATZE_ITEM_IS_FOLDER (item) && strcmp (stock_id, GTK_STOCK_DELETE))
         gtk_widget_set_sensitive (menuitem, uri != NULL);
     g_object_set_data (G_OBJECT (menuitem), "KatzeItem", item);
-    g_signal_connect (menuitem, "activate", G_CALLBACK (callback), bookmarks);
+    if (callback)
+        g_signal_connect (menuitem, "activate", G_CALLBACK (callback), bookmarks);
+    else
+        gtk_widget_set_sensitive (menuitem, FALSE);
     gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
     gtk_widget_show (menuitem);
 }
@@ -766,39 +2107,125 @@
     }
 }
 
+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;
+
+	KATZE_ARRAY_FOREACH_ITEM (child, array)
+	{
+	    GtkWidget* view = midori_bookmarks_open_bookmark_in_tab (child, browser);
+	    if (view)
+		last_view = view;
+	}
+    }
+
+    return last_view;
+}
+
+
+static void
+midori_bookmarks_run_web_application_cb (GtkWidget*       menuitem,
+					 MidoriBookmarks* bookmarks)
+{
+    KatzeItem* item;
+    const gchar* uri;
+
+    item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
+
+    if ((uri = katze_item_get_uri (item)) && *uri)
+    {
+	gchar* uri_fixed = sokoke_magic_uri (uri, TRUE, FALSE);
+	if (!uri_fixed)
+	    uri_fixed = g_strdup (uri);
+   
+        sokoke_spawn_app (uri_fixed, FALSE);
+
+        g_free (uri_fixed);
+    }
+}
+
 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))
-    {
-        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)
-            {
-                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);
-            }
-        }
-    }
-    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);
-    }
+    GtkWidget* last_view = NULL;
+    MidoriBrowser* browser = midori_browser_get_for_widget (GTK_WIDGET (bookmarks));
+    GtkTreeModel* model;
+    GList* rows;
+    gint length;
+    gint i;
+
+    length = katze_tree_view_get_selected_rows (GTK_TREE_VIEW (bookmarks->treeview),
+                                               &model, &rows);
+
+    if (!length)
+    {
+	KatzeItem* root = KATZE_ITEM (bookmarks->array);
+	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
+    {
+	for (i = 0 ; i < length; i++)
+	{
+	    GtkTreeIter iter;
+	    
+	    if (gtk_tree_model_get_iter (
+		    model, &iter, (GtkTreePath *)g_list_nth_data (rows, i)))
+	    {
+		GtkWidget* view = NULL;
+		KatzeItem* item;
+		const gchar* uri;
+		
+		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;
+	    }
+	}
+    
+	g_list_free_full (rows, (GDestroyNotify) gtk_tree_path_free);
+    }
+
+    if (last_view)
+	midori_browser_set_current_tab_smartly (browser, last_view);
 }
 
 static void
@@ -826,32 +2253,113 @@
                         KatzeItem*       item,
                         MidoriBookmarks* bookmarks)
 {
+    KatzeItem* root = KATZE_ITEM (bookmarks->array);      
     GtkWidget* menu;
     GtkWidget* menuitem;
 
     menu = gtk_menu_new ();
-    if (KATZE_ITEM_IS_FOLDER (item))
-        midori_bookmarks_popup_item (menu,
-            STOCK_TAB_NEW, _("Open all in _Tabs"),
-            item, midori_bookmarks_open_in_tab_activate_cb, bookmarks);
+    if ((item == root)
+	|| KATZE_ITEM_IS_FOLDER (item))
+    {
+	gint child_bookmarks_count = midori_array_count_recursive(
+	    bookmarks->array,
+	    "uri <> ''",
+	    NULL,
+	    item,
+	    FALSE);
+
+	if (!child_bookmarks_count) 
+	    midori_bookmarks_popup_item (menu,
+		STOCK_TAB_NEW, _("Open all in _Tabs"),
+		item, NULL, bookmarks);
+	else
+	    midori_bookmarks_popup_item (menu,
+		STOCK_TAB_NEW, _("Open all in _Tabs"),
+		item, midori_bookmarks_open_in_tab_activate_cb, bookmarks);
+    }
     else
     {
-        midori_bookmarks_popup_item (menu, GTK_STOCK_OPEN, NULL,
-            item, midori_bookmarks_open_activate_cb, bookmarks);
+	if (katze_item_get_meta_boolean (item, "app"))
+	{
+	    midori_bookmarks_popup_item (menu, 
+		GTK_STOCK_EXECUTE, _("Open as Web A_pplication"),
+		item, midori_bookmarks_run_web_application_cb, bookmarks);
+	    midori_bookmarks_popup_item (menu, GTK_STOCK_OPEN, NULL,
+		item, midori_bookmarks_open_activate_cb, bookmarks);
+	}
+	else
+	{
+	    midori_bookmarks_popup_item (menu, GTK_STOCK_OPEN, NULL,
+		item, midori_bookmarks_open_activate_cb, bookmarks);
+	    midori_bookmarks_popup_item (menu,
+		GTK_STOCK_EXECUTE, _("Open as Web A_pplication"),
+		item, midori_bookmarks_run_web_application_cb, bookmarks);
+	}
+
         midori_bookmarks_popup_item (menu, STOCK_TAB_NEW, _("Open in New _Tab"),
             item, midori_bookmarks_open_in_tab_activate_cb, bookmarks);
         midori_bookmarks_popup_item (menu, STOCK_WINDOW_NEW, _("Open in New _Window"),
             item, midori_bookmarks_open_in_window_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,
-        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);
+
+    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,
+	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->array), 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->array), 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
@@ -862,32 +2370,198 @@
     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 TRUE;
+    }
+
+    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))
     {
-        KatzeItem* item;
-
-        gtk_tree_model_get (model, &iter, 0, &item, -1);
-
-        if (event->button == 2)
-        {
-            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_browser_add_uri (browser, uri);
-                midori_browser_set_current_tab (browser, view);
-            }
-        }
-        else
-            midori_bookmarks_popup (widget, event, item, bookmarks);
-
-        if (item != NULL)
-            g_object_unref (item);
-        return TRUE;
-    }
+	gboolean done = FALSE;
+        KatzeItem* item;
+
+        gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+        if (KATZE_ITEM_IS_BOOKMARK (item))
+        {
+            MidoriBrowser* browser = midori_browser_get_for_widget (widget);
+            GtkWidget* view = midori_bookmarks_open_bookmark_in_tab (
+		item, browser);
+            
+	    if (widget)
+	    {
+		midori_browser_set_current_tab_smartly (browser, view);
+		done = 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->array);
+      
+        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;
 }
 
@@ -918,46 +2592,82 @@
     }
 }
 
-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
 midori_bookmarks_selection_changed_cb (GtkTreeSelection *treeview,
                                        MidoriBookmarks  *bookmarks)
 {
     midori_bookmarks_toolbar_update (bookmarks);
+    midori_bookmarks_statusbar_update (bookmarks);
 }
 
 static gboolean
@@ -993,6 +2703,123 @@
         midori_bookmarks_filter_timeout_cb, bookmarks, NULL);
 }
 
+static GtkTargetEntry midori_bookmarks_dnd_target_entries[]=
+{
+    {"GTK_TREE_MODEL_MULTI_ROWS", 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 (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 */
+    
+    list_iter = bookmarks->added_paths;
+    while (list_iter)
+    {
+	GtkTreePath* path = (GtkTreePath*)list_iter->data;
+
+	update_items_for_parent (model, path, bookmarks);
+
+	list_iter = g_list_next (list_iter);
+    }
+
+    g_list_free_full (bookmarks->added_paths, (GDestroyNotify) gtk_tree_path_free);
+    bookmarks->added_paths = NULL;
+    
+    /* then finalize updates */
+    g_signal_handlers_block_by_func (bookmarks->array,
+				     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)) 
+    {
+	KatzeItem *item = KATZE_ITEM(key);
+	
+	katze_array_update_item (bookmarks->array, item);
+	g_object_unref (item);
+    }
+
+    g_signal_handlers_unblock_by_func (bookmarks->array,
+				       midori_bookmarks_update_item_cb,
+				       bookmarks);
+
+    g_hash_table_remove_all (bookmarks->updated_items);
+
+    return FALSE;
+}
+ 
+static void
+midori_bookmarks_update_item (MidoriBookmarks* bookmarks, KatzeItem *item)
+{
+    if (!g_hash_table_size (bookmarks->updated_items)
+	|| (!g_list_length (bookmarks->added_paths)))
+	g_idle_add (midori_bookmarks_idle, bookmarks);
+    else 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))
+    {
+	g_hash_table_remove (bookmarks->updated_items, found);
+	g_object_unref (found);
+    }
+}
+ 
 static void
 midori_bookmarks_init (MidoriBookmarks* bookmarks)
 {
@@ -1005,6 +2832,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",
@@ -1015,7 +2844,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);
@@ -1032,29 +2861,49 @@
         (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,
                       NULL);
+
+    MIDORI_BOOKMARKS_TREE_STORE (model)->source_view = GTK_TREE_VIEW (treeview);
+
     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);
     gtk_widget_show (treeview);
     gtk_box_pack_start (GTK_BOX (bookmarks), treeview, TRUE, TRUE, 0);
     bookmarks->treeview = treeview;
+
+    bookmarks->updated_items = g_hash_table_new (item_hash, item_equal);
+    bookmarks->added_paths = NULL;
 }
 
 static void
@@ -1064,5 +2913,9 @@
 
     if (bookmarks->app)
         g_object_unref (bookmarks->app);
+
+    g_idle_remove_by_data (bookmarks);
+    g_hash_table_unref (bookmarks->updated_items);
+    g_list_free_full (bookmarks->added_paths, (GDestroyNotify) gtk_tree_path_free);
+    bookmarks->added_paths = NULL;
 }
-

=== modified file 'tests/bookmarks.c'
--- tests/bookmarks.c	2012-11-25 15:37:41 +0000
+++ tests/bookmarks.c	2013-05-21 05:35:32 +0000
@@ -128,7 +128,7 @@
         }
 
         db_items = midori_array_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);