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

[André Auzi]

[Cris Dywan (kalikiana)]

- if (item->parent)
- katze_array_update ((KatzeArray*)item->parent);
+ if (item->parent && g_strcmp0(icon, picon))
+ katze_array_update_item ((KatzeArray*)item->parent, item);

katze_array_update_item replaces katze_array_update if I see correctly, so that should be mentioned by marking the old one as Deprecated for clarity.

The checks like g_strcmp0(icon, picon) seem to avoid updating if nothing changed - in that case, why not do this for all values in each function?

[Cris Dywan (kalikiana)]

A side note on the comment "panels/midori-bookmarks seems to be a view": yes, historically the code is badly mixed, in an ideal world both the panel and the toolbar should be independent views. Much like the Transfers extension these days.

[André Auzi (aauzi)]

> - if (item->parent)
> - katze_array_update ((KatzeArray*)item->parent);
> + if (item->parent && g_strcmp0(icon, picon))
> + katze_array_update_item ((KatzeArray*)item->parent, item);
>
> katze_array_update_item replaces katze_array_update if I see correctly, so
> that should be mentioned by marking the old one as Deprecated for clarity.

Not exactly... I kept the update for one purpose, the update of the whole data structure.

Basically here, the update in the bookmark panel, clears the whole tree and reloads it.

It thought this use case was still needed for features like bookmark imports, especially the way it is still designed.

Basically, the array_tree is a container. update is signal signaling an item and its containees, update_item only the item.

You probably have noticed that the update_item in the panel basically:
* finds the item in the tree
* unlinks it from where it is
* finds its new parent
* and relinks the item at its new position.

It doesn't do much if the item and its new parent is not visible.

So far, the bookmark bar does not implement such behaviour, it only refresh the whol bar on item change. This would probablye have to be changed for correct DND reordering of the bookmark bar.

> The checks like g_strcmp0(icon, picon) seem to avoid updating if nothing
> changed - in that case, why not do this for all values in each function?

Well, I didn't do it because it would most probably generate a lot of useless signal traffic.
The design I choose make midori/midori-bookmarks robust to poor design that would do multiple updates of the items but I wouldn't not encourage it. I like the speed of midori as it is.

I therefore just kept the automatic signal of the container on containee change where it was in place (I believe it's due to site title and favicon update after page load, isn't it?)

[André Auzi (aauzi)]

> A side note on the comment "panels/midori-bookmarks seems to be a view": yes,
> historically the code is badly mixed, in an ideal world both the panel and the
> toolbar should be independent views. Much like the Transfers extension these
> days.

Yes, I've identified the Model-View-Controller design pattern in the way the code is organised:
* the data base is the Model
* the midori/midori-bookmarks is the Controller
* and bookmarkbar and bookmarkpanel are Views of this model.

With this design pattern actions on the model should go through the controller and that's what I've implemented for delete and update.
I did not do it for insert for two reasons:
1. I didn't intend to change the whole design. I believe there are historical reasons to designs decision that may not be obvious on quick examination. The less I touch the better everybody is :)
2. I do not have a satisfying solution for the provision of the parentid on the insert of a child item I've seen in the file import. No solution => no change.

[Cris Dywan (kalikiana)]

> > The checks like g_strcmp0(icon, picon) seem to avoid updating if nothing
> > changed - in that case, why not do this for all values in each function?

> Well, I didn't do it because it would most probably generate a lot of useless signal traffic.
> The design I choose make midori/midori-bookmarks robust to poor design that would do multiple updates of the > items but I wouldn't not encourage it. I like the speed of midori as it is.

> I therefore just kept the automatic signal of the container on containee change where it was in place
> (I believe it's due to site title and favicon update after page load, isn't it?)

What I meant was to wrap the whole of the values that change, for example:

{
     gchar* pname;
     g_return_if_fail (KATZE_IS_ITEM (item));
     pname = item->name;
     if (item->parent && g_strcmp0(name, pname))
     {
         katze_assign (item->name, g_strdup (name));
         katze_array_update((KatzeArray*)item->parent);
         g_object_notify (G_OBJECT (item), "name");
     }
}

I also realize you're doing "pname = item->name" before g_return_if_fail - don't, it will crash if the assertion is hit. Do it as I do above to be on the safe side.

[André Auzi (aauzi)]

> What I meant was to wrap the whole of the values that change, for example:
>
> {
> gchar* pname;
> g_return_if_fail (KATZE_IS_ITEM (item));
> pname = item->name;
> if (item->parent && g_strcmp0(name, pname))
> {
> katze_assign (item->name, g_strdup (name));
> katze_array_update((KatzeArray*)item->parent);
> g_object_notify (G_OBJECT (item), "name");
> }
> }
>
> I also realize you're doing "pname = item->name" before g_return_if_fail -
> don't, it will crash if the assertion is hit. Do it as I do above to be on the
> safe side.

OK, understood and agreed.
I will change that.

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

6171. By André Auzi on 2013-05-29

1. fix of change value protection in katze_item_set_name and katze_item_set_icon
2. replace remaining katze_array_update by katze_array_update_item in katze_item_set_name
   note: global update katze_array_update mechanism still in use for:
         a- initial populate of bookmarks and extensions,
         b- bookmarks imports
3. fix patch application regression
--- midori/midori-browser.c 2013-05-21 19:20:44 +0000
+++ midori/midori-browser.c 2013-05-28 18:58:04 +0000
@@ -6127,6 +6127,8 @@
         "array", dummy_array /* updated, unique */,
         NULL);
     g_object_connect (action,
+ "signal::populate-folder",
+ _action_bookmarks_populate_folder, browser,
                       "signal::activate-item-alt",
                       midori_bookmarkbar_activate_item_alt, browser,
                       NULL);
@@ -6143,8 +6145,6 @@
         "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",

[André Auzi (aauzi)]

> > A side note on the comment "panels/midori-bookmarks seems to be a view":
> yes,
> > historically the code is badly mixed, in an ideal world both the panel and
> the
> > toolbar should be independent views. Much like the Transfers extension these
> > days.
>
> Yes, I've identified the Model-View-Controller design pattern in the way the
> code is organised:
> * the data base is the Model
> * the midori/midori-bookmarks is the Controller
> * and bookmarkbar and bookmarkpanel are Views of this model.
>
> With this design pattern actions on the model should go through the controller
> and that's what I've implemented for delete and update.
> I did not do it for insert for two reasons:

Let's do a little follow up on this topic.

Thanks to your remark in Bug #1185595 I felt encouraged to investigate the way bookmarks are retrieved from the database.

My investigations led me to two observations:
 1- katze_array_query_recursive is specialized to "bookmarks" table query due to the fact that the bookmarks table name is hard encoded in it
 2- katze_array_query_recursize lacks the feature of identifying folders item and populate them as katze_array of type KATZE_TYPE_ITEM.

My conclusions are the following:
 1- katze_array_query_recursive should be replaced by something like midori_bookmarks_query_recursive
 2- midori_bookmarks_query_recursive should allways select the column 'uri' of bookmarks in order to identify a folder item
 3- it should then parse the result rows for 'uri' value in order to determine if it can populate a katze_item or a katze_array of type KATZE_TYPE_ITEM

The connection with this bug fix proposal is the following.

The new function midori_bookmarks_query_recursive should be implemented in what I identify as the data base controller: midory/midory-bookmarks.c.

This would allow us to implement one additional steps forward in the direction of convergence of the bookmarks data and fix a concern pfor and I share, the triplication of data between bookmarks menu, bookmarkbar item and bookmarks side panel.

The hash table I used to implement packing of updates, or something similar, can also be used for items retrieval, before populating new items, midori_bookmarks_query_recursive should search the bookmarks array for their existence and only populate a new one a last resort.

Of course, the rows data should be inserted in an existing item, different client view may need different metadata.

To integrate well with the existing fix proposal, midori_bookmarks_query_recursive should flush the pending updates.

pfor, again, tipped me on how this flush could be sped up further: updates should be enclosed into SQLite transactions.

Finally, I was mentioning I did not have a solution for the insert, I think it is not the case anymore.

The katze_array_add_item callback of midori/midori-bookmarks.c should actually process the item added in order to make them available in the bookmarks array hash table.

This callback should change a folder implemented in katze_item into an empty katze_array of type
 KATZE_ARRAY_ITEM before inserting it in the database

It should also go through a katze_array of type KATZE_ARRAY:
 1- insert all child bookm...

[André Auzi (aauzi)]

> The consequences on the client views are the following:
> 1- they should ignore add_item of katze_array which are not type
> KATZE_TYPE_ITEM
> 2- they should ignore add_item of katze_item of a folder
>

Additional note:

The consequence on client side may be totally removed if midori_bookmarks derives from katze_array and implements the preprocessing of folders (convert in katze_array of type KATZE_ARRAY_ITEM) and the population of the content of a katze_array is done in a specialization of katze_array_add_item.

By doing so we could ensure that *valid* items would be signaled to the client views.

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

6172. By André Auzi on 2013-06-03

merge lp:midori

6173. By André Auzi on 2013-06-03

merge lp:midori

6174. By André Auzi on 2013-06-04

prototype of bookmarks DB with transactions
+ minor fix in xbel import

6175. By André Auzi on 2013-06-04

merge lp:midori + fix Bookmarks vs Tools menue issue

[André Auzi (aauzi)]

Ok, I've prototyped the ideas shared in the previous comment.

Now, all the database operations are implemented in midori/midori-bookmarks.c using transactions.

The result is impressive, my 883 bookmarks are now imported in #500ms where it was previously taking more than 6s.

The katze_array_query(_recursive) are now replaced by a fixed midori_bookmarks_query_recursive which ensures that the items are not duplicated between the different views.

Well, this is not clean code yet (far from it) but I was so excited by the impressive improvement that I wanted to share it for maybe some stress test feedback.

I therefore resubmit it as it is and will implement suggested changes in a clean update.

review: Needs Resubmitting

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

6176. By André Auzi on 2013-06-05

cleanups and fix of remove and add item issue

6177. By André Auzi on 2013-06-05

merge lp:midori

6178. By André Auzi on 2013-06-05

more cleanups

[André Auzi (aauzi)]

Well, this is now clean enough.

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

6179. By André Auzi on 2013-06-11

implement complete derivation from KatzeArray for proper database interaction.
midori/midori-bookmarks.[ch] -> midori/midori-bookmarks-db.[ch]
class MidoriBookmarksDb created.

6180. By André Auzi on 2013-06-11

merge lp:midori
move midori_array_count_recursive into midori_bookmarks_db_count_recursive

6181. By André Auzi on 2013-06-15

fix relay method selection

6182. By André Auzi on 2013-06-18

revert changes in katze-item and katze-array,
localize them in midori-bookmarks-db

6183. By André Auzi on 2013-06-18

merge lp:midori

6184. By André Auzi on 2013-06-18

insert change 6208 from lp:midori

6185. By André Auzi on 2013-06-18

cosmetics coding style

6186. By André Auzi on 2013-06-18

adapt bookmarks unit tests and fix add item issue

6187. By André Auzi on 2013-06-18

cleanup update_item implementation

6188. By André Auzi on 2013-07-09

merge lp:midori

6189. By André Auzi on 2013-08-05

merge lp:midori

6190. By André Auzi on 2013-08-05

fix potential memory leak

Unmerged revisions

6190. By André Auzi on 2013-08-05

fix potential memory leak

6189. By André Auzi on 2013-08-05

merge lp:midori

6188. By André Auzi on 2013-07-09

merge lp:midori

6187. By André Auzi on 2013-06-18

cleanup update_item implementation

6186. By André Auzi on 2013-06-18

adapt bookmarks unit tests and fix add item issue

6185. By André Auzi on 2013-06-18

cosmetics coding style

6184. By André Auzi on 2013-06-18

insert change 6208 from lp:midori

6183. By André Auzi on 2013-06-18

merge lp:midori

6182. By André Auzi on 2013-06-18

revert changes in katze-item and katze-array,
localize them in midori-bookmarks-db

6181. By André Auzi on 2013-06-15

fix relay method selection

=== modified file 'katze/katze-array.c'
--- katze/katze-array.c	2012-08-08 23:02:56 +0000
+++ katze/katze-array.c	2013-06-05 17:59:27 +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-06-05 17:59:27 +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-06-05 17:59:27 +0000
@@ -316,9 +316,12 @@
 {
     g_return_if_fail (KATZE_IS_ITEM (item));
 
+    if (!g_strcmp0 (item->name, name))
+        return;
+
     katze_assign (item->name, g_strdup (name));
     if (item->parent)
-        katze_array_update ((KatzeArray*)item->parent);
+        katze_array_update_item ((KatzeArray*)item->parent, item);
     g_object_notify (G_OBJECT (item), "name");
 }
 
@@ -420,9 +423,12 @@
 {
     g_return_if_fail (KATZE_IS_ITEM (item));
 
+    if (!g_strcmp0 (katze_item_get_meta_string (item, "icon"), icon))
+        return;
+
     katze_item_set_meta_string (item, "icon", icon);
     if (item->parent)
-        katze_array_update ((KatzeArray*)item->parent);
+        katze_array_update_item ((KatzeArray*)item->parent, item);
     g_object_notify (G_OBJECT (item), "icon");
 }
 

=== modified file 'midori/midori-array.c'
--- midori/midori-array.c	2013-04-16 23:16:24 +0000
+++ midori/midori-array.c	2013-06-05 17:59:27 +0000
@@ -97,15 +97,15 @@
         if (katze_str_equal ((gchar*)cur->name, "title"))
         {
             gchar* value = g_strstrip ((gchar*)xmlNodeGetContent (cur));
+            katze_item_set_name (KATZE_ITEM (array), value);
+            xmlFree (value);
+        }
+        else if (katze_str_equal ((gchar*)cur->name, "desc"))
+        {
+            gchar* value = g_strstrip ((gchar*)xmlNodeGetContent (cur));
             katze_item_set_text (KATZE_ITEM (array), value);
             xmlFree (value);
         }
-        else if (katze_str_equal ((gchar*)cur->name, "desc"))
-        {
-            gchar* value = g_strstrip ((gchar*)xmlNodeGetContent (cur));
-            katze_item_set_name (KATZE_ITEM (array), value);
-            xmlFree (value);
-        }
         else if (katze_str_equal ((gchar*)cur->name, "info"))
             katze_xbel_parse_info ((KatzeItem*)array, cur);
         else if (katze_str_equal ((gchar*)cur->name, "folder"))
@@ -986,7 +986,7 @@
     return FALSE;
 }
 
-static void
+/* static */ void
 katze_item_set_value_from_column (sqlite3_stmt* stmt,
                                   gint          column,
                                   KatzeItem*    item)
@@ -1116,6 +1116,8 @@
  * Return value: a #KatzeArray on success, %NULL otherwise
  *
  * Since: 0.4.4
+ *
+ * Deprecated: 0.5.2: Use midori_bookmarks_query_recursive() instead.
  **/
 KatzeArray*
 midori_array_query_recursive (KatzeArray*  bookmarks,

=== modified file 'midori/midori-bookmarks.c'
--- midori/midori-bookmarks.c	2012-11-25 15:37:41 +0000
+++ midori/midori-bookmarks.c	2013-06-05 17:59:27 +0000
@@ -25,6 +25,30 @@
     #include <unistd.h>
 #endif
 
+#define MIDORI_BOOKMARKS_DB_CONTROL(a) ((MidoriBookmarksDBControl*)(a)) 
+typedef struct _MidoriBookmarksDBControl MidoriBookmarksDBControl;
+struct _MidoriBookmarksDBControl
+{
+    sqlite3*    db;
+    GList*      pending_inserts; 
+    GHashTable* pending_updates; 
+    GHashTable* pending_deletes; 
+    GHashTable* all_items; 
+};
+
+static gint64
+midori_bookmarks_insert_item_db (sqlite3*   db,
+                                 KatzeItem* item,
+                                 gint64     parentid);
+
+static gboolean
+midori_bookmarks_update_item_db (sqlite3*   db,
+                                 KatzeItem* item);
+
+static gboolean
+midori_bookmarks_remove_item_db (sqlite3*   db,
+                                 KatzeItem* item);
+
 void
 midori_bookmarks_dbtracer (void*       dummy,
                            const char* query)
@@ -32,35 +56,415 @@
     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_begin_transaction (sqlite3* db)
+{
+    char* errmsg = NULL;
+
+    if (sqlite3_exec (db, "BEGIN TRANSACTION;", NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        g_printerr (_("Failed to begin transaction: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+midori_bookmarks_end_transaction (sqlite3* db, gboolean commit)
+{
+    char* errmsg = NULL;
+    if (sqlite3_exec (db, (commit ? "COMMIT;" : "ROLLBACK;"), NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        if (commit)
+            g_printerr (_("Failed to end transaction: %s\n"), errmsg);
+        else
+            g_printerr (_("Failed to cancel transaction: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gint
+midori_bookmarks_insert_item (MidoriBookmarksDBControl* control,
+    KatzeItem* item)
+{
+    GList* list;
+    KatzeArray* array;
+    gint64 id = 0;
+    gint count = 0;
+    gint64 parentid = katze_item_get_meta_integer (item, "parentid");
+    
+    id = midori_bookmarks_insert_item_db (control->db, item, parentid);
+    count++;
+    
+    g_object_ref (item);
+    g_hash_table_insert (control->all_items, item, item);
+
+    if (!KATZE_IS_ARRAY (item))
+        return count;
+
+    array = KATZE_ARRAY (item);
+
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+        katze_item_set_meta_integer (item, "parentid", id);
+        count += midori_bookmarks_insert_item (control, item);
+    }
+
+    g_list_free (list);
+    return count;
+}
+
+static void
+midori_bookmarks_remove_item (KatzeItem*  item,
+                              MidoriBookmarksDBControl* control)
+{
+    gint64 id = katze_item_get_meta_integer (item, "id");
+    GHashTableIter hash_iter;
+    gpointer key, value;
+    gpointer found;
+    GList* childs = NULL;
+    GList* list_iter;
+
+    if (found = g_list_find (control->pending_inserts, item))
+    {
+        g_object_unref (((GList*)found)->data);
+        control->pending_inserts = g_list_delete_link (control->pending_inserts, 
+            ((GList*)found));
+    }
+
+    if (found = g_hash_table_lookup (control->pending_updates, item))
+    {
+        g_hash_table_remove (control->pending_updates, found);
+        g_object_unref (found);
+    }
+
+    if (found = g_hash_table_lookup (control->all_items, item))
+    {
+        g_hash_table_remove (control->all_items, found);
+        g_object_unref (found);
+    }
+
+    if (!KATZE_ITEM_IS_FOLDER (item))
+        return;
+
+    g_hash_table_iter_init (&hash_iter, control->all_items);
+    
+    while (g_hash_table_iter_next (&hash_iter, &key, &value)) 
+    {
+        KatzeItem *hash_item = KATZE_ITEM (value);
+        gint64 parentid = katze_item_get_meta_integer (hash_item, "parentid");
+
+        if (parentid != id)
+            continue;
+        
+        childs = g_list_append (childs, hash_item);
+    }
+
+    for (list_iter = childs; list_iter; list_iter = g_list_next (list_iter))
+    {
+        KatzeItem *list_item = KATZE_ITEM (list_iter->data);
+        
+        midori_bookmarks_remove_item (list_item, control);
+    }
+
+    g_list_free (childs);
+}
+
+static gboolean
+midori_bookmarks_idle_func (gpointer data)
+{
+    GTimer *timer = g_timer_new();
+    gint count = 0;
+    gulong microseconds;
+    gboolean with_transaction;
+    KatzeArray* bookmarks = KATZE_ARRAY (data);
+    MidoriBookmarksDBControl* control = g_object_get_data (G_OBJECT (bookmarks), "control");
+    GList* list_iter;
+    GHashTableIter hash_iter;
+    gpointer key, value;
+
+    g_timer_start (timer);
+
+    with_transaction = midori_bookmarks_begin_transaction (control->db);
+    
+    for (list_iter = control->pending_inserts; list_iter; list_iter = g_list_next (list_iter)) 
+    {
+        KatzeItem *item = KATZE_ITEM (list_iter->data);
+
+        count += midori_bookmarks_insert_item (control, item);
+
+        g_object_unref (item);
+    }
+
+    g_hash_table_iter_init (&hash_iter, control->pending_updates);
+
+    while (g_hash_table_iter_next (&hash_iter, &key, &value)) 
+    {
+        KatzeItem *item = KATZE_ITEM (value);
+	
+        midori_bookmarks_update_item_db (control->db, item);
+        g_object_unref (item);
+        count++;
+    }
+
+    g_hash_table_iter_init (&hash_iter, control->pending_deletes);
+
+    while (g_hash_table_iter_next (&hash_iter, &key, &value)) 
+    {
+        KatzeItem *item = KATZE_ITEM (value);
+	
+        midori_bookmarks_remove_item_db (control->db, item);
+        g_object_unref (item);
+        count++;
+    }
+
+    if (with_transaction)
+        midori_bookmarks_end_transaction (control->db, TRUE);
+
+    g_timer_elapsed (timer, &microseconds);
+    g_print ("midori_bookmarks_idle: %d DB operation(s) in %lu micro-seconds\n",
+        count, microseconds);
+
+    g_timer_destroy (timer);
+
+    g_hash_table_remove_all (control->pending_deletes);
+    g_hash_table_remove_all (control->pending_updates);
+    g_list_free (control->pending_inserts);
+    control->pending_inserts = NULL;
+
+    return FALSE;
+}
+
+static void
+midori_bookmarks_idle_start (KatzeArray* array,
+                             MidoriBookmarksDBControl* control)
+{
+    if (control->pending_inserts
+        || g_hash_table_size (control->pending_updates)
+        || g_hash_table_size (control->pending_deletes))
+        return;
+    
+    g_idle_add (midori_bookmarks_idle_func, array);
+}
+
+static void
 midori_bookmarks_add_item_cb (KatzeArray* array,
                               KatzeItem*  item,
-                              sqlite3*    db)
-{
-    midori_bookmarks_insert_item_db (db, item,
-        katze_item_get_meta_integer (item, "parentid"));
-}
-
-void
+                              MidoriBookmarksDBControl* control)
+{
+    gpointer found = g_list_find (control->pending_inserts, item);
+    
+    if (found)
+        return;
+
+    midori_bookmarks_idle_start (array, control);
+
+    g_object_ref (item);
+    control->pending_inserts = g_list_append (control->pending_inserts, item);
+}
+
+static void
+midori_bookmarks_update_item_cb (KatzeArray* array,
+				 KatzeItem*  item,
+				 MidoriBookmarksDBControl* control)
+{
+    gpointer found = g_hash_table_lookup (control->pending_updates, item);
+
+    if (found)
+        return;
+
+    midori_bookmarks_idle_start (array, control);
+
+    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)
-{
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-
-
-    sqlcmd = sqlite3_mprintf (
-            "DELETE FROM bookmarks WHERE id = %" G_GINT64_FORMAT ";",
+                                 MidoriBookmarksDBControl* control)
+{
+    gpointer found = g_hash_table_lookup (control->pending_deletes, item);
+
+    if (found)
+        return;
+
+    midori_bookmarks_idle_start (array, control);
+
+    midori_bookmarks_remove_item (item, control);
+
+    g_object_ref (item);
+    g_hash_table_insert (control->pending_deletes, item, item);
+}
+
+static gint64
+midori_bookmarks_insert_item_db (sqlite3*   db,
+                                 KatzeItem* item,
+                                 gint64     parentid)
+{
+    gchar* sqlcmd;
+    char* errmsg = NULL;
+    KatzeItem* old_parent;
+    gchar* new_parentid;
+    gchar* id = NULL;
+    const gchar* uri = NULL;
+    const gchar* desc = NULL;
+    gint64 seq = 0;
+
+    /* Bookmarks must have a name, import may produce invalid items */
+    g_return_val_if_fail (katze_item_get_name (item), seq);
+
+    if (!db)
+        return seq;
+
+    if (katze_item_get_meta_integer (item, "id") > 0)
+        id = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer(item, "id"));
+    else
+        id = g_strdup_printf ("NULL");
+
+    if (KATZE_ITEM_IS_BOOKMARK (item))
+        uri = katze_item_get_uri (item);
+
+    if (katze_item_get_text (item))
+        desc = katze_item_get_text (item);
+
+    /* Use folder, otherwise fallback to parent folder */
+    old_parent = katze_item_get_parent (item);
+    if (parentid > 0)
+        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
+    else if (old_parent && katze_item_get_meta_integer (old_parent, "id") > 0)
+        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer (old_parent, "id"));
+    else
+        new_parentid = g_strdup_printf ("NULL");
+
+    sqlcmd = sqlite3_mprintf (
+            "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
+            "VALUES (%q, %q, '%q', '%q', '%q', %d, %d)",
+            id,
+            new_parentid,
+            katze_item_get_name (item),
+            katze_str_non_null (uri),
+            katze_str_non_null (desc),
+            katze_item_get_meta_boolean (item, "toolbar"),
+            katze_item_get_meta_boolean (item, "app"));
+
+    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) == SQLITE_OK)
+    {
+        /* Get insert id */
+        if (g_str_equal (id, "NULL"))
+        {
+            KatzeArray* seq_array;
+
+            sqlite3_free (sqlcmd);
+            sqlcmd = sqlite3_mprintf (
+                    "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
+
+            seq_array = katze_array_from_sqlite (db, sqlcmd);
+            if (katze_array_get_nth_item (seq_array, 0))
+            {
+                KatzeItem* seq_item = katze_array_get_nth_item (seq_array, 0);
+
+                seq = katze_item_get_meta_integer (seq_item, "seq");
+                katze_item_set_meta_integer (item, "id", seq);
+            }
+            g_object_unref (seq_array);
+        }
+    }
+    else
+    {
+        g_printerr (_("Failed to add bookmark item: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+    }
+
+    sqlite3_free (sqlcmd);
+    g_free (new_parentid);
+    g_free (id);
+
+    return seq;
+}
+
+static gboolean
+midori_bookmarks_update_item_db (sqlite3*   db,
+                                 KatzeItem* item)
+{
+    gchar* sqlcmd;
+    char* errmsg = NULL;
+    gchar* parentid;
+    gboolean updated;
+
+    if (katze_item_get_meta_integer (item, "parentid") > 0)
+        parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
+                                    katze_item_get_meta_integer (item, "parentid"));
+    else
+        parentid = g_strdup_printf ("NULL");
+
+    sqlcmd = sqlite3_mprintf (
+            "UPDATE bookmarks SET "
+            "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
+            "WHERE id = %" G_GINT64_FORMAT ";",
+            parentid,
+            katze_item_get_name (item),
+            katze_str_non_null (katze_item_get_uri (item)),
+            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, "id"));
 
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
-    {
-        g_printerr (_("Failed to remove history item: %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
+    updated = TRUE;
+    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        updated = FALSE;
+        g_printerr (_("Failed to update bookmark : %s\n"), errmsg);
+        sqlite3_free (errmsg);
+    }
+
+    sqlite3_free (sqlcmd);
+    g_free (parentid);
+
+    return updated;
+}
+
+static gboolean
+midori_bookmarks_remove_item_db (sqlite3*    db,
+                                 KatzeItem*  item)
+{
+    char* errmsg = NULL;
+    gchar* sqlcmd;
+    gboolean removed = TRUE;
+
+    sqlcmd = sqlite3_mprintf (
+        "DELETE FROM bookmarks WHERE id = %" G_GINT64_FORMAT ";",
+        katze_item_get_meta_integer (item, "id"));
+
+    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
+    {
+        g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
+        sqlite3_free (errmsg);
+        removed = FALSE;
+    }
+
+    sqlite3_free (sqlcmd);
+    return removed;
 }
 
 #define _APPEND_TO_SQL_ERRORMSG(custom_errmsg) \
@@ -141,6 +545,7 @@
     gchar* sql_errmsg = NULL;
     gchar* import_errmsg = NULL;
     KatzeArray* array;
+    MidoriBookmarksDBControl* control;
 
     g_return_val_if_fail (errmsg != NULL, NULL);
 
@@ -279,12 +684,21 @@
     init_success:
         g_free (newfile);
         g_free (oldfile);
+        control = MIDORI_BOOKMARKS_DB_CONTROL (g_malloc (sizeof (*control)));
+        control->db = db;
+        control->pending_inserts = NULL;
+        control->pending_updates = g_hash_table_new (item_hash, item_equal);
+        control->pending_deletes = g_hash_table_new (item_hash, item_equal);
+        control->all_items = 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:
@@ -298,24 +712,6 @@
 }
 
 void
-midori_bookmarks_import (const gchar* filename,
-                         sqlite3*     db)
-{
-    KatzeArray* bookmarks;
-    GError* error = NULL;
-
-    bookmarks = katze_array_new (KATZE_TYPE_ARRAY);
-
-    if (!midori_array_from_file (bookmarks, filename, "xbel", &error))
-    {
-        g_warning (_("The bookmarks couldn't be saved. %s"), error->message);
-        g_error_free (error);
-        return;
-    }
-    midori_bookmarks_import_array_db (db, bookmarks, 0);
-}
-
-void
 midori_bookmarks_on_quit (KatzeArray* array)
 {
     g_return_if_fail (KATZE_IS_ARRAY (array));
@@ -323,5 +719,196 @@
     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_idle_remove_by_data (array);
+    g_list_free (control->pending_inserts);
+    g_hash_table_unref (control->pending_updates);
+    g_hash_table_unref (control->pending_deletes);
+    g_hash_table_unref (control->all_items);
+}
+
+/**
+ * midori_bookmarks_import_array:
+ * @array: the main bookmark array
+ * @array: #KatzeArray containing the items to import
+ * @parentid: the id of folder
+ *
+ * Imports the items of @array as childs of the folder
+ * identfied by @parentid.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_import_array (KatzeArray* bookmarks,
+                               KatzeArray* array,
+                               gint64      parentid)
+{
+    GList* list;
+    KatzeItem* item;
+
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+        katze_item_set_meta_integer (item, "parentid", parentid);
+        katze_array_add_item (bookmarks, item);
+    }
+
+    g_list_free (list);
+}
+
+static void
+midori_bookmarks_force_idle (KatzeArray* array,
+                             MidoriBookmarksDBControl* control)
+{
+    if (g_idle_remove_by_data (array))
+        midori_bookmarks_idle_func (array);
+}
+
+/* static */ void
+katze_item_set_value_from_column (sqlite3_stmt* stmt,
+                                  gint          column,
+                                  KatzeItem*    item);
+
+static KatzeArray*
+midori_bookmarks_array_from_statement (sqlite3_stmt* stmt, 
+                            MidoriBookmarksDBControl* control)
+{
+    KatzeArray *array;
+    gint result;
+    gint cols;
+
+    array = katze_array_new (KATZE_TYPE_ITEM);
+    cols = sqlite3_column_count (stmt);
+
+    while ((result = sqlite3_step (stmt)) == SQLITE_ROW)
+    {
+        gint i;
+        KatzeItem* item;
+        KatzeItem* found;
+
+        item = katze_item_new ();
+        for (i = 0; i < cols; i++)
+            katze_item_set_value_from_column (stmt, i, item);
+
+        if (found = g_hash_table_lookup (control->all_items, item))
+        {
+            for (i = 0; i < cols; i++)
+                katze_item_set_value_from_column (stmt, i, found);
+
+            g_object_unref (item);
+
+            item = found;
+        }
+        else if (KATZE_ITEM_IS_FOLDER (item))
+        {
+            item = KATZE_ITEM (katze_array_new (KATZE_TYPE_ITEM));
+            
+            for (i = 0; i < cols; i++)
+                katze_item_set_value_from_column (stmt, i, item);
+            
+            g_object_ref (item);
+            g_hash_table_insert (control->all_items, item, item);
+        }
+        else
+        {
+            g_object_ref (item);
+            g_hash_table_insert (control->all_items, item, item);
+        }
+
+        katze_array_add_item (array, item);
+    }
+
+    sqlite3_clear_bindings (stmt);
+    sqlite3_reset (stmt);
+    return array;
+}
+
+static KatzeArray*
+midori_bookmarks_array_from_sqlite (KatzeArray* array,
+                         const gchar* sqlcmd)
+{
+    MidoriBookmarksDBControl* control;
+    sqlite3_stmt* stmt;
+    gint result;
+
+    control = g_object_get_data (G_OBJECT (array), "control");
+    g_return_val_if_fail (control != NULL, NULL);
+
+    midori_bookmarks_force_idle (array, control);
+
+    result = sqlite3_prepare_v2 (control->db, sqlcmd, -1, &stmt, NULL);
+    if (result != SQLITE_OK)
+        return NULL;
+
+    return midori_bookmarks_array_from_statement (stmt, control);
+}
+
+/**
+ * midori_bookmarks_query_recursive:
+ * @array: the main bookmark array
+ * @fields: comma separated list of fields
+ * @condition: condition, like "folder = '%q'"
+ * @value: a value to be inserted if @condition contains %q
+ * @recursive: if %TRUE include children
+ *
+ * Stores the result in a #KatzeArray.
+ *
+ * Return value: a #KatzeArray on success, %NULL otherwise
+ *
+ * Since: 0.5.2
+ **/
+KatzeArray*
+midori_bookmarks_query_recursive (KatzeArray*  bookmarks,
+                                  const gchar* fields,
+                                  const gchar* condition,
+                                  const gchar* value,
+                                  gboolean     recursive)
+{
+    gchar* sqlcmd;
+    char* sqlcmd_value;
+    KatzeArray* array;
+    KatzeItem* item;
+    GList* list;
+
+    g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), NULL);
+    g_return_val_if_fail (fields, NULL);
+    g_return_val_if_fail (condition, NULL);
+
+    sqlcmd = g_strdup_printf ("SELECT %s FROM bookmarks WHERE %s "
+                              "ORDER BY (uri='') ASC, title DESC", fields, condition);
+    if (strstr (condition, "%q"))
+    {
+        sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
+        array = midori_bookmarks_array_from_sqlite (bookmarks, sqlcmd_value);
+        sqlite3_free (sqlcmd_value);
+    }
+    else
+        array = midori_bookmarks_array_from_sqlite (bookmarks, sqlcmd);
+    g_free (sqlcmd);
+
+    if (!recursive)
+        return array;
+
+    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
+    {
+        if (KATZE_ITEM_IS_FOLDER (item))
+        {
+            gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
+                katze_item_get_meta_integer (item, "id"));
+            KatzeArray* subarray = midori_bookmarks_query_recursive (bookmarks,
+                fields, "parentid=%q", parentid, TRUE);
+            KatzeItem* subitem;
+            GList* sublist;
+
+            KATZE_ARRAY_FOREACH_ITEM_L (subitem, subarray, sublist)
+            {
+                katze_array_add_item (KATZE_ARRAY (item), subitem);
+            }
+
+            g_object_unref (subarray);
+            g_free (parentid);
+        }
+    }
+    g_list_free (list);
+    return array;
+}

=== modified file 'midori/midori-bookmarks.h'
--- midori/midori-bookmarks.h	2012-11-25 15:37:41 +0000
+++ midori/midori-bookmarks.h	2013-06-05 17:59:27 +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);
 
@@ -33,8 +23,16 @@
 midori_bookmarks_on_quit (KatzeArray* array);
 
 void
-midori_bookmarks_import (const gchar* filename,
-                         sqlite3*     db);
+midori_bookmarks_import_array (KatzeArray* bookmarks,
+                               KatzeArray* array,
+                               gint64      parentid);
+
+KatzeArray*
+midori_bookmarks_query_recursive (KatzeArray*  bookmarks,
+                                  const gchar* fields,
+                                  const gchar* condition,
+                                  const gchar* value,
+                                  gboolean     recursive);
 
 #endif /* !__MIDORI_BOOKMARKS_H__ */
 

=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-05-31 03:40:27 +0000
+++ midori/midori-browser.c	2013-06-05 17:59:27 +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)
@@ -162,20 +164,13 @@
                              GParamSpec* pspec);
 
 void
-midori_bookmarks_import_array_db (sqlite3*    db,
-                                  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 +479,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",
@@ -1061,16 +1059,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;
 }
@@ -3096,8 +3089,8 @@
     else
         condition = "parentid = %q";
 
-    bookmarks = midori_array_query (browser->bookmarks,
-        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id);
+    bookmarks = midori_bookmarks_query_recursive (browser->bookmarks,
+        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
     if (!bookmarks)
         return FALSE;
 
@@ -4486,7 +4479,7 @@
             if (error)
                 g_error_free (error);
         }
-        midori_bookmarks_import_array_db (db, bookmarks, selected);
+        midori_bookmarks_import_array (browser->bookmarks, bookmarks, selected);
         katze_array_update (browser->bookmarks);
         g_object_unref (bookmarks);
         g_free (path);
@@ -4541,7 +4534,7 @@
         return;
 
     error = NULL;
-    bookmarks = midori_array_query_recursive (browser->bookmarks,
+    bookmarks = midori_bookmarks_query_recursive (browser->bookmarks,
         "*", "parentid IS NULL", NULL, TRUE);
     if (!midori_array_to_file (bookmarks, path, format, &error))
     {
@@ -5968,6 +5961,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)
 {
@@ -6448,6 +6456,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);
 }
 
@@ -6962,7 +6972,7 @@
                                 KatzeItem* item)
 {
     MidoriBrowser* browser = midori_browser_get_for_widget (toolbar);
-    GtkAction* action = _action_by_name (browser, "Tools");
+    GtkAction* action = _action_by_name (browser, "Bookmarks");
     GtkToolItem* toolitem = katze_array_action_create_tool_item_for (
         KATZE_ARRAY_ACTION (action), item);
     g_object_set_data (G_OBJECT (toolitem), "KatzeItem", item);
@@ -6983,6 +6993,28 @@
 }
 
 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);
+    midori_browser_update_history (item, "bookmark", "modify");
+}
+
+static void
 midori_bookmarkbar_remove_item_cb (KatzeArray*    bookmarks,
                                    KatzeItem*     item,
                                    MidoriBrowser* browser)
@@ -6995,6 +7027,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;
 
@@ -7004,8 +7046,8 @@
     gtk_toolbar_insert (GTK_TOOLBAR (browser->bookmarkbar),
                         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);
+    array = midori_bookmarks_query_recursive (browser->bookmarks,
+        "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
     if (!array)
     {
         _action_set_sensitive (browser, "BookmarkAdd", FALSE);
@@ -7015,21 +7057,7 @@
 
     KATZE_ARRAY_FOREACH_ITEM (item, array)
     {
-        if (KATZE_ITEM_IS_BOOKMARK (item))
-            midori_bookmarkbar_insert_item (browser->bookmarkbar, item);
-        else
-        {
-            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);
-
-                katze_item_set_name (KATZE_ITEM (subfolder), katze_item_get_name (item));
-                katze_item_set_meta_integer (KATZE_ITEM (subfolder), "id", id);
-                midori_bookmarkbar_insert_item (browser->bookmarkbar, KATZE_ITEM (subfolder));
-            g_free (parentid);
-        }
+        midori_bookmarkbar_insert_item (browser->bookmarkbar, item);
     }
     _action_set_sensitive (browser, "BookmarkAdd", TRUE);
     _action_set_sensitive (browser, "BookmarkFolderAdd", TRUE);
@@ -7064,8 +7092,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);
@@ -7094,6 +7129,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 'panels/midori-bookmarks.c'
--- panels/midori-bookmarks.c	2013-02-11 21:49:41 +0000
+++ panels/midori-bookmarks.c	2013-06-05 17:59:27 +0000
@@ -25,6 +25,111 @@
 
 #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_row_drop_possible (GtkTreeDragDest   *drag_dest,
+					      GtkTreePath       *dest_path,
+					      GtkSelectionData  *selection_data);
+
+typedef struct _MidoriBookmarksTreeStore                MidoriBookmarksTreeStore;
+typedef struct _MidoriBookmarksTreeStoreClass           MidoriBookmarksTreeStoreClass;
+
+struct _MidoriBookmarksTreeStore
+{
+    GtkTreeStore parent_instance;
+};
+
+struct _MidoriBookmarksTreeStoreClass
+{
+    GtkTreeStoreClass parent_class;
+};
+
+static GtkTreeDragDestIface *
+gtk_tree_store_gtk_tree_drag_dest_iface = NULL;
+
+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;
+}
+
+static void
+midori_bookmarks_tree_store_init (MidoriBookmarksTreeStore* item)
+{
+}
+
+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_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 +141,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 +160,8 @@
 
     gint filter_timeout;
     gchar* filter;
+
+    GList* pending_inserts;
 };
 
 struct _MidoriBookmarksClass
@@ -86,6 +199,13 @@
                                GParamSpec* pspec);
 
 static void
+midori_bookmarks_add_item_cb (KatzeArray*      array,
+                              KatzeItem*       item,
+                              MidoriBookmarks* bookmarks);
+static void
+midori_bookmarks_update_cb (KatzeArray*      array,
+                            MidoriBookmarks* bookmarks);
+static void
 midori_bookmarks_class_init (MidoriBookmarksClass* class)
 {
     GObjectClass* gobject_class;
@@ -120,6 +240,7 @@
     return STOCK_BOOKMARKS;
 }
 
+#if 0
 /* TODO: Function never used */
 void
 midori_bookmarks_export_array_db (sqlite3*    db,
@@ -133,7 +254,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_bookmarks_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
     {
         g_free (parent_id);
         return;
@@ -155,27 +276,7 @@
     g_free (parent_id);
     g_list_free (list);
 }
-
-void
-midori_bookmarks_import_array_db (sqlite3*    db,
-                                  KatzeArray* array,
-                                  gint64      parentid)
-{
-    GList* list;
-    KatzeItem* item;
-    gint64 id;
-
-    if (!db)
-        return;
-
-    KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
-    {
-        id = midori_bookmarks_insert_item_db (db, item, parentid);
-        if (KATZE_IS_ARRAY (item))
-            midori_bookmarks_import_array_db (db, KATZE_ARRAY (item), id);
-    }
-    g_list_free (list);
-}
+#endif
 
 static KatzeArray*
 midori_bookmarks_read_from_db (MidoriBookmarks* bookmarks,
@@ -185,21 +286,21 @@
     KatzeArray* array;
 
     if (keyword && *keyword)
-        array = midori_array_query (bookmarks->array,
-           "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword);
+        array = midori_bookmarks_query_recursive (bookmarks->array,
+            "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
     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);
+            array = midori_bookmarks_query_recursive (bookmarks->array,
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
 
             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);
+            array = midori_bookmarks_query_recursive (bookmarks->array,
+                "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
     }
     return array ? array : katze_array_new (KATZE_TYPE_ITEM);
 }
@@ -230,90 +331,133 @@
         g_object_unref (item);
 }
 
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid)
+static gboolean
+midori_bookmarks_reach_item_recurse (GtkTreeModel* model,
+				     GtkTreeIter* iter,
+				     gint64 id)
 {
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-    KatzeItem* old_parent;
-    gchar* new_parentid;
-    gchar* id = NULL;
-    const gchar* uri = NULL;
-    const gchar* desc = NULL;
-    gint64 seq = 0;
-
-    /* Bookmarks must have a name, import may produce invalid items */
-    g_return_val_if_fail (katze_item_get_name (item), seq);
-
-    if (!db)
-        return seq;
-
-    if (katze_item_get_meta_integer (item, "id") > 0)
-        id = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer(item, "id"));
-    else
-        id = g_strdup_printf ("NULL");
-
-    if (KATZE_ITEM_IS_BOOKMARK (item))
-        uri = katze_item_get_uri (item);
-
-    if (katze_item_get_text (item))
-        desc = katze_item_get_text (item);
-
-    /* Use folder, otherwise fallback to parent folder */
-    old_parent = katze_item_get_parent (item);
-    if (parentid > 0)
-        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    else if (old_parent && katze_item_get_meta_integer (old_parent, "id") > 0)
-        new_parentid = g_strdup_printf ("%" G_GINT64_FORMAT, katze_item_get_meta_integer (old_parent, "id"));
-    else
-        new_parentid = g_strdup_printf ("NULL");
-
-    sqlcmd = sqlite3_mprintf (
-            "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
-            "VALUES (%q, %q, '%q', '%q', '%q', %d, %d)",
-            id,
-            new_parentid,
-            katze_item_get_name (item),
-            katze_str_non_null (uri),
-            katze_str_non_null (desc),
-            katze_item_get_meta_boolean (item, "toolbar"),
-            katze_item_get_meta_boolean (item, "app"));
-
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) == SQLITE_OK)
+    do
     {
-        /* Get insert id */
-        if (g_str_equal (id, "NULL"))
-        {
-            KatzeArray* seq_array;
-
-            sqlite3_free (sqlcmd);
-            sqlcmd = sqlite3_mprintf (
-                    "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
-
-            seq_array = katze_array_from_sqlite (db, sqlcmd);
-            if (katze_array_get_nth_item (seq_array, 0))
+        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))
             {
-                KatzeItem* seq_item = katze_array_get_nth_item (seq_array, 0);
-
-                seq = katze_item_get_meta_integer (seq_item, "seq");
-                katze_item_set_meta_integer (item, "id", seq);
+                *iter = child;
+                return TRUE;
             }
-            g_object_unref (seq_array);
         }
     }
-    else
-    {
-        g_printerr (_("Failed to add bookmark item: %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
-    g_free (new_parentid);
-    g_free (id);
-
-    return seq;
+    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(GtkTreeStore*    model,
+				   GtkTreeIter*     parent,
+				   KatzeItem*       item)
+{
+    if (KATZE_ITEM_IS_BOOKMARK (item))
+    {
+	gchar* tooltip = g_markup_escape_text (katze_item_get_uri (item), -1);
+
+	gtk_tree_store_insert_with_values (model, NULL, parent,
+					   0, 
+					   0, item, 1, tooltip, -1);
+	g_free (tooltip);
+    }
+    else
+    {
+	GtkTreeIter root_iter;
+
+	gtk_tree_store_insert_with_values (model, &root_iter, parent,
+					   0, 0, item, -1);
+
+	/* That's an invisible dummy, so we always have an expander */
+	gtk_tree_store_insert_with_values (model, NULL, &root_iter, 
+					   0, 
+					   0, NULL, -1);
+    }
+}
+
+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 (KatzeItem*       item,
+                           MidoriBookmarks* bookmarks);
+
+static gboolean
+midori_bookmarks_idle (MidoriBookmarks* bookmarks)
+{
+    GList* list_iter;
+    
+    for (list_iter = bookmarks->pending_inserts; list_iter; list_iter = g_list_next (list_iter)) 
+    {
+        KatzeItem *item = KATZE_ITEM (list_iter->data);
+
+        midori_bookmarks_add_item (item, bookmarks);
+
+        g_object_unref (item);
+    }
+
+    g_list_free (bookmarks->pending_inserts);
+    bookmarks->pending_inserts = NULL;
+    
+    return FALSE;
 }
 
 static void
@@ -321,11 +465,98 @@
                               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);
+    if (!bookmarks->pending_inserts)
+        g_idle_add ((GSourceFunc)midori_bookmarks_idle, bookmarks);
+
+    g_object_ref (item);
+    bookmarks->pending_inserts = g_list_append (bookmarks->pending_inserts, item);
+}
+
+static void
+midori_bookmarks_add_item (KatzeItem*       item,
+                           MidoriBookmarks* bookmarks)
+{
+    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;
+    
+    if (!parentid)
+    {
+        midori_bookmarks_add_item_to_model (GTK_TREE_STORE (model), NULL, item);
+    }
+    else if (midori_bookmarks_reach_item (model, &iter, parentid))
+    {
+        GtkTreePath* path = gtk_tree_model_get_path(model, &iter);
+	
+        if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (bookmarks->treeview), path))
+        {
+            midori_bookmarks_add_item_to_model (GTK_TREE_STORE (model), &iter, item);
+        }
+
+        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;
+
+    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 (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 (item, bookmarks);
+        }
+    }
+    else
+        midori_bookmarks_add_item (item, bookmarks);
 }
 
 static void
@@ -333,12 +564,36 @@
                                  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;
+    
+    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);
+        }
+    }
 }
 
+
 static void
 midori_bookmarks_update_cb (KatzeArray*      array,
                             MidoriBookmarks* bookmarks)
@@ -350,6 +605,42 @@
 }
 
 
+static gboolean
+midori_bookmarks_tree_store_row_drop_possible (GtkTreeDragDest*  drag_dest,
+					                           GtkTreePath*      dest_path,
+					                           GtkSelectionData* selection_data)
+{
+    gboolean row_drop_possible = 
+     gtk_tree_store_gtk_tree_drag_dest_iface->row_drop_possible (drag_dest,
+         dest_path,
+         selection_data);
+
+    if (!row_drop_possible)
+        return FALSE;
+
+    if ((!gtk_tree_path_get_depth(dest_path) > 1)
+        && gtk_tree_path_up(dest_path))
+    {
+        GtkTreeModel* model = GTK_TREE_MODEL(drag_dest);
+        GtkTreeIter iter;
+
+        if (gtk_tree_model_get_iter (model, &iter, dest_path))
+        {
+            KatzeItem* item;
+	    
+            gtk_tree_model_get (model, &iter, 0, &item, -1);
+
+            if (!KATZE_ITEM_IS_FOLDER(item))
+                row_drop_possible = FALSE;
+	    
+            if (item)
+                g_object_unref (item);
+        }
+    }
+
+    return row_drop_possible;
+}
+
 static void
 midori_bookmarks_row_changed_cb (GtkTreeModel*    model,
                                  GtkTreePath*     path,
@@ -358,31 +649,37 @@
 {
     KatzeItem* item;
     GtkTreeIter parent;
-    KatzeItem* new_parent = NULL;
-    gint64 parentid;
-
-    gtk_tree_model_get (model, iter, 0, &item, -1);
+    gint64 parentid = 0;
 
     if (gtk_tree_model_iter_parent (model, &parent, iter))
     {
+        KatzeItem* new_parent;
+
         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");
+        /* Bookmarks cannot be moved into non-folder items */
+        g_assert (KATZE_ITEM_IS_FOLDER (new_parent));
+
+        parentid = katze_item_get_meta_integer (new_parent, "id");
+
+        g_object_unref (new_parent);
     }
-    else
-        parentid = 0;
-
-    katze_array_remove_item (bookmarks->array, item);
+
+    gtk_tree_model_get (model, iter, 0, &item, -1);
+
     katze_item_set_meta_integer (item, "parentid", parentid);
-    katze_array_add_item (bookmarks->array, item);
+
+    g_signal_handlers_block_by_func (bookmarks->array,
+        midori_bookmarks_update_item_cb, 
+        bookmarks);
+
+    katze_array_update_item (bookmarks->array, item);
+
+    g_signal_handlers_unblock_by_func (bookmarks->array,
+        midori_bookmarks_update_item_cb, 
+        bookmarks);
 
     g_object_unref (item);
-    if (new_parent)
-        g_object_unref (new_parent);
 }
 
 static void
@@ -408,24 +705,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);
     }
 }
@@ -441,47 +729,6 @@
     gtk_widget_set_sensitive (GTK_WIDGET (bookmarks->edit), selected);
 }
 
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-                                 KatzeItem* item)
-{
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-    gchar* parentid;
-    gboolean updated;
-
-    if (katze_item_get_meta_integer (item, "parentid") > 0)
-        parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
-                                    katze_item_get_meta_integer (item, "parentid"));
-    else
-        parentid = g_strdup_printf ("NULL");
-
-    sqlcmd = sqlite3_mprintf (
-            "UPDATE bookmarks SET "
-            "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
-            "WHERE id = %" G_GINT64_FORMAT ";",
-            parentid,
-            katze_item_get_name (item),
-            katze_str_non_null (katze_item_get_uri (item)),
-            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, "id"));
-
-    updated = TRUE;
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
-    {
-        updated = FALSE;
-        g_printerr (_("Failed to update bookmark : %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
-    g_free (parentid);
-
-    return updated;
-}
-
 static void
 midori_bookmarks_delete_clicked_cb (GtkWidget*       toolitem,
                                     MidoriBookmarks* bookmarks)
@@ -496,13 +743,8 @@
 
         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);
     }
 }
@@ -599,6 +841,8 @@
     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",
@@ -1015,7 +1259,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);
@@ -1055,6 +1299,7 @@
     gtk_widget_show (treeview);
     gtk_box_pack_start (GTK_BOX (bookmarks), treeview, TRUE, TRUE, 0);
     bookmarks->treeview = treeview;
+    bookmarks->pending_inserts = NULL;
 }
 
 static void

=== modified file 'panels/midori-bookmarks.h'
--- panels/midori-bookmarks.h	2012-11-25 11:26:03 +0000
+++ panels/midori-bookmarks.h	2013-06-05 17:59:27 +0000
@@ -37,20 +37,6 @@
 GType
 midori_bookmarks_get_type               (void);
 
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid);
-
-void
-midori_bookmarks_import_array_db (sqlite3*    db,
-                                  KatzeArray* array,
-                                  gint64      parentid);
-
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-                                 KatzeItem* item);
-
 G_END_DECLS
 
 #endif /* __MIDORI_BOOKMARKS_PANEL_H__ */