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

[Cris Dywan]

Introduces KatzeArray::update-item to handle metadata changes

Fifth step for merge of fix-1179200

Here the midori_bookmarks_db class is derived from KatzeArray.

It provides the API for bookmarks db operations.

It introduces the update-item signal, which is used by the bookmark bar and the bookmarks panel to handle bookmarks metadata changes.

So far, the bookmark item may still be duplicated (created by the HMI or retrieved from the database)

[Cris Dywan (kalikiana)]

There's considerable whitespace-only changes making the patch much larger than it would otherwise be.

Exposing KatzeArray internals without using a "private" is problematic. Any change to the struct affects ABI.

There's a non-trivial #if 0 without documentation.

review: Needs Fixing

[Cody Garver (codygarver)]

There are also merge artifacts in the diff like line 137

review: Needs Fixing

[982c80311320c1b (alexander-wilms)]

I tried to resolve the conflict: lp:~alexander-wilms/midori/fix-1179200-5-without-conflicts

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

6325. By André Auzi on 2013-09-17

fix indentation errors

[André Auzi (aauzi)]

> There are also merge artifacts in the diff like line 137
I'm puzzled by this issue, I do see the artifacts in the diff here but not in the branch itself when I branch it again on my laptop.

Could it be a bzr/launchpad issue?

[André Auzi (aauzi)]

> There's considerable whitespace-only changes making the patch much larger than
> it would otherwise be.
>

My apologies for that, I guess I have to polish my emacs c-style for midori.
Anyway, I've tried to fix this.

> Exposing KatzeArray internals without using a "private" is problematic. Any
> change to the struct affects ABI.
>

OK, I'm on it

> There's a non-trivial #if 0 without documentation.

It was to make sure that the comment just underneath was correct and the enclosed function was actually not used.

If it was my code I would just get rid of the unused function.

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

6326. By André Auzi on 2013-09-17

make KatzeArray struct content private

6327. By André Auzi on 2013-09-17

merge lp:midori to fix conficts

[André Auzi (aauzi)]

> > There are also merge artifacts in the diff like line 137
> I'm puzzled by this issue, I do see the artifacts in the diff here but not in
> the branch itself when I branch it again on my laptop.
>
> Could it be a bzr/launchpad issue?

OK I figured it was merge conflicts indicators.
I fixed it by merging in lp:midori

[Cris Dywan (kalikiana)]

Thanks!

review: Approve

=== modified file 'katze/katze-array.c'
--- katze/katze-array.c	2012-08-08 23:02:56 +0000
+++ katze/katze-array.c	2013-09-17 19:35:27 +0000
@@ -25,38 +25,14 @@
  * #KatzeArray is a type aware container for items.
  */
 
-struct _KatzeArray
+G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
+
+struct _KatzeArrayPrivate
 {
-    KatzeItem parent_instance;
-
     GType type;
     GList* items;
 };
 
-struct _KatzeArrayClass
-{
-    KatzeItemClass parent_class;
-
-    /* Signals */
-    void
-    (*add_item)               (KatzeArray* array,
-                               gpointer    item);
-    void
-    (*remove_item)            (KatzeArray* array,
-                               gpointer    item);
-    void
-    (*move_item)              (KatzeArray* array,
-                               gpointer    item,
-                               gint        index);
-    void
-    (*clear)                  (KatzeArray* array);
-
-    void
-    (*update)                 (KatzeArray* array);
-};
-
-G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
-
 enum {
     ADD_ITEM,
     REMOVE_ITEM,
@@ -90,7 +66,7 @@
     if (g_type_is_a (type, KATZE_TYPE_ITEM))
         katze_item_set_parent (item, array);
 
-    array->items = g_list_append (array->items, item);
+    array->priv->items = g_list_append (array->priv->items, item);
     _katze_array_update (array);
 }
 
@@ -98,7 +74,7 @@
 _katze_array_remove_item (KatzeArray* array,
                           gpointer   item)
 {
-    array->items = g_list_remove (array->items, item);
+    array->priv->items = g_list_remove (array->priv->items, item);
 
     if (KATZE_IS_ITEM (item))
         katze_item_set_parent (item, NULL);
@@ -111,8 +87,8 @@
                         gpointer    item,
                         gint        position)
 {
-    array->items = g_list_remove (array->items, item);
-    array->items = g_list_insert (array->items, item, position);
+    array->priv->items = g_list_remove (array->priv->items, item);
+    array->priv->items = g_list_insert (array->priv->items, item, position);
     _katze_array_update (array);
 }
 
@@ -121,10 +97,10 @@
 {
     GObject* item;
 
-    while ((item = g_list_nth_data (array->items, 0)))
+    while ((item = g_list_nth_data (array->priv->items, 0)))
         g_signal_emit (array, signals[REMOVE_ITEM], 0, item);
-    g_list_free (array->items);
-    array->items = NULL;
+    g_list_free (array->priv->items);
+    array->priv->items = NULL;
     _katze_array_update (array);
 }
 
@@ -217,13 +193,18 @@
     class->move_item = _katze_array_move_item;
     class->clear = _katze_array_clear;
     class->update = _katze_array_update;
+
+    g_type_class_add_private (class, sizeof (KatzeArrayPrivate));
 }
 
 static void
 katze_array_init (KatzeArray* array)
 {
-    array->type = G_TYPE_OBJECT;
-    array->items = NULL;
+    array->priv = G_TYPE_INSTANCE_GET_PRIVATE (array,
+        KATZE_TYPE_ARRAY, KatzeArrayPrivate);
+
+    array->priv->type = G_TYPE_OBJECT;
+    array->priv->items = NULL;
 }
 
 static void
@@ -232,9 +213,9 @@
     KatzeArray* array = KATZE_ARRAY (object);
     GList* items;
 
-    for (items = array->items; items; items = g_list_next (items))
+    for (items = array->priv->items; items; items = g_list_next (items))
         g_object_unref (items->data);
-    g_list_free (array->items);
+    g_list_free (array->priv->items);
 
     G_OBJECT_CLASS (katze_array_parent_class)->finalize (object);
 }
@@ -258,7 +239,7 @@
     g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
 
     array = g_object_new (KATZE_TYPE_ARRAY, NULL);
-    array->type = type;
+    array->priv->type = type;
 
     return array;
 }
@@ -279,7 +260,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), FALSE);
 
-    return g_type_is_a (array->type, is_a_type);
+    return g_type_is_a (array->priv->type, is_a_type);
 }
 
 /**
@@ -333,7 +314,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
 
-    return g_list_nth_data (array->items, n);
+    return g_list_nth_data (array->priv->items, n);
 }
 
 /**
@@ -349,7 +330,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), TRUE);
 
-    return !g_list_nth_data (array->items, 0);
+    return !g_list_nth_data (array->priv->items, 0);
 }
 
 /**
@@ -367,7 +348,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), -1);
 
-    return g_list_index (array->items, item);
+    return g_list_index (array->priv->items, item);
 }
 
 /**
@@ -401,7 +382,7 @@
     if (token_length < 1)
         token_length = strlen (token);
 
-    for (items = array->items; items; items = g_list_next (items))
+    for (items = array->priv->items; items; items = g_list_next (items))
     {
         const gchar* found_token = ((KatzeItem*)items->data)->token;
         if (found_token != NULL)
@@ -439,7 +420,7 @@
     g_return_val_if_fail (katze_array_is_a (array, KATZE_TYPE_ITEM), NULL);
     g_return_val_if_fail (uri != NULL, NULL);
 
-    for (items = array->items; items; items = g_list_next (items))
+    for (items = array->priv->items; items; items = g_list_next (items))
     {
         const gchar* found_uri = ((KatzeItem*)items->data)->uri;
         if (found_uri != NULL && !strcmp (found_uri, uri))
@@ -461,7 +442,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), 0);
 
-    return g_list_length (array->items);
+    return g_list_length (array->priv->items);
 }
 
 /**
@@ -499,7 +480,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
 
-    return g_list_copy (array->items);
+    return g_list_copy (array->priv->items);
 }
 
 GList*
@@ -507,7 +488,7 @@
 {
     g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
 
-    return array->items;
+    return array->priv->items;
 }
 
 /**
 
=== modified file 'katze/katze-array.h'
--- katze/katze-array.h	2011-01-19 20:58:26 +0000
+++ katze/katze-array.h	2013-09-17 19:35:27 +0000
@@ -31,6 +31,36 @@
 
 typedef struct _KatzeArray                       KatzeArray;
 typedef struct _KatzeArrayClass                  KatzeArrayClass;
+typedef struct _KatzeArrayPrivate                KatzeArrayPrivate;
+
+struct _KatzeArray
+{
+    KatzeItem parent_instance;
+
+    KatzeArrayPrivate* priv;
+};
+
+struct _KatzeArrayClass
+{
+    KatzeItemClass parent_class;
+
+    /* Signals */
+    void
+    (*add_item)               (KatzeArray* array,
+                               gpointer    item);
+    void
+    (*remove_item)            (KatzeArray* array,
+                               gpointer    item);
+    void
+    (*move_item)              (KatzeArray* array,
+                               gpointer    item,
+                               gint        index);
+    void
+    (*clear)                  (KatzeArray* array);
+
+    void
+    (*update)                 (KatzeArray* array);
+};
 
 GType
 katze_array_get_type               (void) G_GNUC_CONST;
 
=== modified file 'katze/katze-item.c'
--- katze/katze-item.c	2013-07-27 12:35:55 +0000
+++ katze/katze-item.c	2013-09-17 19:35:27 +0000
@@ -314,6 +314,9 @@
 {
     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);
@@ -418,6 +421,9 @@
 {
     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);
 
=== modified file 'midori/midori-array.c'
--- midori/midori-array.c	2013-08-05 12:50:34 +0000
+++ midori/midori-array.c	2013-09-17 19:35:27 +0000
@@ -986,7 +986,17 @@
     return FALSE;
 }
 
-static void
+/**
+ * katze_item_set_value_from_columne:
+ * @stmt: prepared statement
+ * @column: column to read
+ * @item: #KatzeItem to populate
+ *
+ * Stores the column in the given #KatzeItem.
+ *
+ * Since: 0.2.7
+ **/
+void
 katze_item_set_value_from_column (sqlite3_stmt* stmt,
                                   gint          column,
                                   KatzeItem*    item)
 
=== modified file 'midori/midori-bookmarks-db.c'
--- midori/midori-bookmarks-db.c	2013-09-08 10:53:32 +0000
+++ midori/midori-bookmarks-db.c	2013-09-17 19:35:27 +0000
@@ -25,14 +25,324 @@
     #include <unistd.h>
 #endif
 
-static gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
-				 KatzeItem* item);
-
-gint64
-midori_bookmarks_insert_item_db (sqlite3*   db,
-                                 KatzeItem* item,
-                                 gint64     parentid)
+/**
+ * SECTION:midory-bookmarks-db
+ * @short_description: A #KatzeArray connected to a database
+ * @see_also: #KatzeArray
+ *
+ * #MidoriBookmarksDb is a #KatzeArray specialized for database
+ * interraction.
+ */
+
+struct _MidoriBookmarksDb
+{
+    KatzeArray  parent_instance;
+
+    sqlite3*    db;
+};
+
+struct _MidoriBookmarksDbClass
+{
+    KatzeArrayClass parent_class;
+
+    /* Signals */
+    void
+    (*update_item)            (MidoriBookmarksDb* bookmarks,
+                               gpointer    item);
+};
+
+G_DEFINE_TYPE (MidoriBookmarksDb, midori_bookmarks_db, KATZE_TYPE_ARRAY);
+
+enum {
+    UPDATE_ITEM,
+
+    LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+static void
+_midori_bookmarks_db_add_item (KatzeArray* array,
+                               gpointer    item);
+
+static void
+_midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks,
+                                  gpointer    item);
+
+static void
+_midori_bookmarks_db_remove_item (KatzeArray* array,
+                                  gpointer   item);
+
+static void
+_midori_bookmarks_db_move_item (KatzeArray* array,
+                                gpointer    item,
+                                gint        position);
+
+static void
+_midori_bookmarks_db_clear (KatzeArray* array);
+
+static void
+midori_bookmarks_db_finalize (GObject* object);
+
+static gint64
+midori_bookmarks_db_insert_item_db (sqlite3*   db,
+                                    KatzeItem* item,
+                                    gint64     parentid);
+
+static gboolean
+midori_bookmarks_db_update_item_db (sqlite3*   db,
+                                    KatzeItem* item);
+
+static gboolean
+midori_bookmarks_db_remove_item_db (sqlite3*   db,
+                                    KatzeItem* item);
+
+static void
+midori_bookmarks_db_class_init (MidoriBookmarksDbClass* class)
+{
+    GObjectClass* gobject_class;
+    KatzeArrayClass* katze_array_class;
+
+    gobject_class = G_OBJECT_CLASS (class);
+    gobject_class->finalize = midori_bookmarks_db_finalize;
+
+    signals[UPDATE_ITEM] = g_signal_new (
+        "update-item",
+        G_TYPE_FROM_CLASS (class),
+        (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+        G_STRUCT_OFFSET (MidoriBookmarksDbClass, update_item),
+        0,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE, 1,
+        G_TYPE_POINTER);
+
+    katze_array_class = KATZE_ARRAY_CLASS (class);
+
+    katze_array_class->add_item = _midori_bookmarks_db_add_item;
+    katze_array_class->remove_item = _midori_bookmarks_db_remove_item;
+    katze_array_class->move_item = _midori_bookmarks_db_move_item;
+    katze_array_class->clear = _midori_bookmarks_db_clear;
+
+    class->update_item = _midori_bookmarks_db_update_item;
+}
+
+static void
+midori_bookmarks_db_init (MidoriBookmarksDb* bookmarks)
+{
+    bookmarks->db = NULL;
+
+    katze_item_set_meta_integer (KATZE_ITEM (bookmarks), "id", 0);
+    katze_item_set_name (KATZE_ITEM (bookmarks), _("Bookmarks"));
+    /* g_object_ref (bookmarks); */
+}
+
+static void
+midori_bookmarks_db_finalize (GObject* object)
+{
+    MidoriBookmarksDb* bookmarks = MIDORI_BOOKMARKS_DB (object);
+
+    if (bookmarks->db)
+    {
+        sqlite3_close (bookmarks->db);
+    }
+
+    G_OBJECT_CLASS (midori_bookmarks_db_parent_class)->finalize (object);
+}
+
+/**
+ * midori_bookmarks_db_get_item_parent:
+ * @bookmarks: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that find the parent of the @item thanks to its %parentid
+ **/
+static KatzeArray*
+midori_bookmarks_db_get_item_parent (MidoriBookmarksDb* bookmarks,
+                                     gpointer    item)
+{
+    KatzeArray* parent;
+    gint64 parentid;
+
+    parentid = katze_item_get_meta_integer (KATZE_ITEM (item), "parentid");
+
+    if (parentid == 0)
+    {
+        parent = KATZE_ARRAY (bookmarks);
+    }
+    else
+    {
+        parent = NULL;
+    }
+
+    return parent;
+}
+
+/**
+ * _midori_bookmarks_db_add_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_add_item().
+ * It relays the add item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_add_item (KatzeArray* array,
+                               gpointer    item)
+{
+    MidoriBookmarksDb *bookmarks;
+    KatzeArray* parent;
+    KatzeArray* db_parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    bookmarks = MIDORI_BOOKMARKS_DB (array);
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    db_parent = midori_bookmarks_db_get_item_parent (bookmarks, item);
+
+    g_return_if_fail (db_parent);
+
+    if (parent == db_parent)
+    {
+        if (IS_MIDORI_BOOKMARKS_DB (parent))
+            KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->update (parent);
+        else
+            katze_array_update (parent);
+        return;
+    }
+
+    if (IS_MIDORI_BOOKMARKS_DB (parent))
+        KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->add_item (parent, item);
+    else
+        katze_array_add_item (parent, item);
+}
+
+/**
+ * _midori_bookmarks_db_update_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that implements the %midori_bookmarks_db_update_item() post-processing.
+ * It relays an update to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks,
+                                  gpointer    item)
+{
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    katze_array_update (parent);
+}
+
+/**
+ * _midori_bookmarks_db_remove_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_remove_item().
+ * It relays the remove item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_remove_item (KatzeArray* array,
+                                  gpointer   item)
+{
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    if (IS_MIDORI_BOOKMARKS_DB (parent))
+        KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->remove_item (parent, item);
+    else
+        katze_array_remove_item (parent, item);
+}
+
+/**
+ * _midori_bookmarks_db_move_item:
+ * @array: the main bookmarks array
+ * @item: a #KatzeItem
+ * @position: the new @item position
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_move_item().
+ * It relays the move @item to the appropriate #KatzeArray.
+ **/
+static void
+_midori_bookmarks_db_move_item (KatzeArray* array,
+                                gpointer    item,
+                                gint        position)
+{
+    MidoriBookmarksDb *bookmarks;
+    KatzeArray* parent;
+
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+
+    parent = katze_item_get_parent (KATZE_ITEM (item));
+
+    g_return_if_fail (parent);
+
+    KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->move_item (parent, item, position);
+}
+
+/**
+ * _midori_bookmarks_db_clear:
+ * @array: the main bookmarks array
+ *
+ * Internal function that overloads the #KatzeArray %katze_array_clear().
+ * It deletes the whole bookmarks data.
+ **/
+static void
+_midori_bookmarks_db_clear (KatzeArray* array)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+
+    g_critical ("_midori_bookmarks_db_clear: not implemented\n");
+}
+
+/**
+ * midori_bookmarks_db_signal_update_item:
+ * @array: a #KatzeArray
+ * @item: an item
+ *
+ * Notify an update of the item of the array.
+ *
+ **/
+static void
+midori_bookmarks_db_signal_update_item (MidoriBookmarksDb* array,
+                                        gpointer    item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
+
+    g_signal_emit (array, signals[UPDATE_ITEM], 0, item);
+}
+
+/**
+ * midori_bookmarks_db_insert_item_db:
+ * @db: the #sqlite3
+ * @item: #KatzeItem the item to insert
+ *
+ * Internal function that does the actual SQL INSERT of the @item in @db.
+ *
+ * Since: 0.5.2
+ **/
+static gint64
+midori_bookmarks_db_insert_item_db (sqlite3*   db,
+                                    KatzeItem* item,
+                                    gint64     parentid)
 {
     gchar* sqlcmd;
     char* errmsg = NULL;
@@ -70,15 +380,15 @@
         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"));
+        "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)
     {
@@ -89,7 +399,7 @@
 
             sqlite3_free (sqlcmd);
             sqlcmd = sqlite3_mprintf (
-                    "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
+                "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))
@@ -115,8 +425,17 @@
     return seq;
 }
 
-gboolean
-midori_bookmarks_update_item_db (sqlite3*   db,
+/**
+ * midori_bookmarks_db_update_item_db:
+ * @db: the #sqlite3
+ * @item: #KatzeItem the item to update
+ *
+ * Internal function that does the actual SQL UPDATE of the @item in @db.
+ *
+ * Since: 0.5.2
+ **/
+static gboolean
+midori_bookmarks_db_update_item_db (sqlite3*   db,
                                  KatzeItem* item)
 {
     gchar* sqlcmd;
@@ -126,7 +445,7 @@
     gchar* id;
 
     id = g_strdup_printf ("%" G_GINT64_FORMAT,
-            katze_item_get_meta_integer (item, "id"));
+                          katze_item_get_meta_integer (item, "id"));
 
     if (katze_item_get_meta_integer (item, "parentid") > 0)
         parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
@@ -135,16 +454,16 @@
         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 = %q ;",
-            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"),
-            id);
+        "UPDATE bookmarks SET "
+        "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
+        "WHERE id = %q ;",
+        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"),
+        id);
 
     updated = TRUE;
     if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
@@ -162,68 +481,104 @@
 }
 
 /**
+ * midori_bookmarks_db_remove_item_db:
+ * @db: the #sqlite3
+ * @item: #KatzeItem the item to delete
+ *
+ * Internal function that does the actual SQL DELETE of the @item in @db.
+ *
+ * Since: 0.5.2
+ **/
+static gboolean
+midori_bookmarks_db_remove_item_db (sqlite3*    db,
+                                    KatzeItem*  item)
+{
+    char* errmsg = NULL;
+    gchar* sqlcmd;
+    gboolean removed = TRUE;
+    gchar* id;
+
+    id = g_strdup_printf ("%" G_GINT64_FORMAT,
+                          katze_item_get_meta_integer (item, "id"));
+
+    sqlcmd = sqlite3_mprintf ("DELETE FROM bookmarks WHERE id = %q", 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);
+    g_free (id);
+    return removed;
+}
+
+/**
+ * midori_bookmarks_db_add_item:
+ * @bookmarks: the main bookmark array
+ * @item: #KatzeItem the item to update
+ *
+ * Adds the @item in the bookmark data base.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_db_add_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+    g_return_if_fail (NULL == katze_item_get_meta_string (item, "id"));
+
+    midori_bookmarks_db_insert_item_db (bookmarks->db, item,
+                                        katze_item_get_meta_integer (item, "parentid"));
+
+    katze_array_add_item (KATZE_ARRAY (bookmarks), item);
+}
+
+/**
  * midori_bookmarks_db_update_item:
  * @bookmarks: the main bookmark array
  * @item: #KatzeItem the item to update
  *
  * Updates the @item in the bookmark data base.
  *
- * Since: 0.5.5
- **/
-void
-midori_array_update_item (KatzeArray* bookmarks,
-			  KatzeItem* item)
-{
-    g_return_if_fail (KATZE_IS_ARRAY (bookmarks));
-    g_return_if_fail (KATZE_IS_ITEM (item));
-    g_return_if_fail (katze_item_get_meta_string (item, "id"));
-    g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
-
-    sqlite3* db = g_object_get_data (G_OBJECT (bookmarks), "db");
-
-    g_return_if_fail (db);
-
-    midori_bookmarks_update_item_db (db, item);
-}
-
-void
-midori_bookmarks_dbtracer (void*       dummy,
-                           const char* query)
-{
-    g_printerr ("%s\n", query);
-}
-
-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"));
-}
-
-static void
-midori_bookmarks_remove_item_cb (KatzeArray* array,
-                                 KatzeItem*  item,
-                                 sqlite3*    db)
-{
-    gchar* sqlcmd;
-    char* errmsg = NULL;
-    gchar* id;
-
-    id = g_strdup_printf ("%" G_GINT64_FORMAT,
-            katze_item_get_meta_integer (item, "id"));
-
-    sqlcmd = sqlite3_mprintf ("DELETE FROM bookmarks WHERE id = %q", id);
-
-    if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
-    {
-        g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
-        sqlite3_free (errmsg);
-    }
-
-    sqlite3_free (sqlcmd);
-    g_free (id);
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+    g_return_if_fail (katze_item_get_meta_string (item, "id"));
+    g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
+
+    midori_bookmarks_db_update_item_db (bookmarks->db, item);
+
+    midori_bookmarks_db_signal_update_item (bookmarks, item);
+}
+
+/**
+ * midori_bookmarks_db_remove_item:
+ * @bookmarks: the main bookmark array
+ * @item: #KatzeItem the item to remove
+ *
+ * Removes the @item from the bookmark data base.
+ *
+ * Since: 0.5.2
+ **/
+void
+midori_bookmarks_db_remove_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
+{
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ITEM (item));
+    g_return_if_fail (katze_item_get_meta_string (item, "id"));
+    g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
+
+    midori_bookmarks_db_remove_item_db (bookmarks->db, item);
+
+    katze_array_remove_item (KATZE_ARRAY (bookmarks), item);
 }
 
 #define _APPEND_TO_SQL_ERRORMSG(custom_errmsg) \
@@ -237,8 +592,8 @@
             g_string_append (errmsg_str, custom_errmsg); \
     } while (0)
 
-gboolean
-midori_bookmarks_import_from_old_db (sqlite3*     db,
+static gboolean
+midori_bookmarks_db_import_from_old_db (sqlite3*     db,
                                      const gchar* oldfile,
                                      gchar**      errmsg)
 {
@@ -293,8 +648,24 @@
 }
 #undef _APPEND_TO_SQL_ERRORMSG
 
-KatzeArray*
-midori_bookmarks_new (char** errmsg)
+static void
+midori_bookmarks_db_dbtracer (void*       dummy,
+                              const char* query)
+{
+    g_printerr ("%s\n", query);
+}
+
+/**
+ * midori_bookmarks_db_new:
+ *
+ * Initializes the bookmark data base.
+ *
+ * Returns: the main bookmarks array
+ *
+ * Since: 0.5.2
+ **/
+MidoriBookmarksDb*
+midori_bookmarks_db_new (char** errmsg)
 {
     sqlite3* db;
     gchar* oldfile;
@@ -304,6 +675,7 @@
     gchar* sql_errmsg = NULL;
     gchar* import_errmsg = NULL;
     KatzeArray* array;
+    MidoriBookmarksDb* bookmarks;
 
     g_return_val_if_fail (errmsg != NULL, NULL);
 
@@ -321,7 +693,7 @@
     }
 
     if (midori_debug ("bookmarks"))
-        sqlite3_trace (db, midori_bookmarks_dbtracer, NULL);
+        sqlite3_trace (db, midori_bookmarks_db_dbtracer, NULL);
 
     create_stmt =     /* Table structure */
         "CREATE TABLE IF NOT EXISTS bookmarks "
@@ -442,7 +814,7 @@
 
     if (oldfile_exists)
         /* import from old db */
-        if (!midori_bookmarks_import_from_old_db (db, oldfile, &import_errmsg))
+        if (!midori_bookmarks_db_import_from_old_db (db, oldfile, &import_errmsg))
         {
             *errmsg = g_strdup_printf (_("Couldn't import from old database: %s\n"),
                 import_errmsg ? import_errmsg : "(err = NULL)");
@@ -452,13 +824,11 @@
     init_success:
         g_free (newfile);
         g_free (oldfile);
-        array = katze_array_new (KATZE_TYPE_ARRAY);
-        g_signal_connect (array, "add-item",
-                          G_CALLBACK (midori_bookmarks_add_item_cb), db);
-        g_signal_connect (array, "remove-item",
-                          G_CALLBACK (midori_bookmarks_remove_item_cb), db);
-        g_object_set_data (G_OBJECT (array), "db", db);
-        return array;
+        bookmarks = MIDORI_BOOKMARKS_DB (g_object_new (TYPE_MIDORI_BOOKMARKS_DB, NULL));
+        bookmarks->db = db;
+
+        g_object_set_data (G_OBJECT (bookmarks), "db", db);
+        return bookmarks;
 
     init_failed:
         g_free (newfile);
@@ -470,40 +840,140 @@
         return NULL;
 }
 
+/**
+ * midori_bookmarks_db_on_quit:
+ * @bookmarks: the main bookmark array
+ *
+ * Delete the main bookmark array.
+ *
+ * Since: 0.5.2
+ **/
 void
-midori_bookmarks_on_quit (KatzeArray* array)
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* bookmarks)
 {
-    g_return_if_fail (KATZE_IS_ARRAY (array));
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
 
-    sqlite3* db = g_object_get_data (G_OBJECT (array), "db");
-    g_return_if_fail (db != NULL);
-    sqlite3_close (db);
+    g_object_unref (bookmarks);
 }
 
+/**
+ * midori_bookmarks_db_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,
+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
                                KatzeArray* array,
                                gint64      parentid)
 {
     GList* list;
     KatzeItem* item;
 
-    if (!bookmarks)
-        return;
+    g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
+    g_return_if_fail (KATZE_IS_ARRAY (array));
 
     KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
     {
         katze_item_set_meta_integer (item, "parentid", parentid);
-        katze_array_add_item (bookmarks, item);
+        midori_bookmarks_db_add_item (bookmarks, item);
         if (KATZE_IS_ARRAY (item))
-          midori_bookmarks_import_array (bookmarks, KATZE_ARRAY (item),
-                                         katze_item_get_meta_integer(item, "id"));
+        midori_bookmarks_db_import_array (bookmarks, KATZE_ARRAY (item),
+                          katze_item_get_meta_integer(item, "id"));
     }
     g_list_free (list);
 }
 
 /**
- * midori_array_query_recursive:
+ * midori_bookmarks_db_array_from_statement:
+ * @stmt: the sqlite returned statement
+ * @bookmarks: the database controller
+ *
+ * Internal function that populate a #KatzeArray by processing the @stmt
+ * rows identifying:
+ * a- if the item is already in memory
+ *    in this case the item data is updated with retreived database content
+ *    and the already existing item is populated in the returned #KatzeArray
+ * b- if the data is a folder
+ *    a new #KatzeArray item is populated in the returned  #KatzeArray and
+ *    memorized for future use.
+ * c- if the data is a bookmark
+ *    a new #KatzeItem item is populated in the returned  #KatzeArray and
+ *    memorized for furure use.
+ *
+ * Return value: the populated #KatzeArray
+ **/
+static KatzeArray*
+midori_bookmarks_db_array_from_statement (sqlite3_stmt* stmt,
+                                       MidoriBookmarksDb* bookmarks)
+{
+    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 (KATZE_ITEM_IS_FOLDER (item))
+        {
+            g_object_unref (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);
+        }
+
+        katze_array_add_item (array, item);
+    }
+
+    sqlite3_clear_bindings (stmt);
+    sqlite3_reset (stmt);
+    return array;
+}
+
+/**
+ * midori_bookmarks_db_array_from_sqlite:
+ * @array: the main bookmark array
+ * @sqlcmd: the sqlcmd to execute
+ *
+ * Internal function that process the requested @sqlcmd.
+ *
+ * Return value: a #KatzeArray on success, %NULL otherwise
+ **/
+static KatzeArray*
+midori_bookmarks_db_array_from_sqlite (MidoriBookmarksDb* bookmarks,
+                                    const gchar* sqlcmd)
+{
+    sqlite3_stmt* stmt;
+    gint result;
+
+    g_return_val_if_fail (bookmarks->db != NULL, NULL);
+
+    result = sqlite3_prepare_v2 (bookmarks->db, sqlcmd, -1, &stmt, NULL);
+    if (result != SQLITE_OK)
+        return NULL;
+
+    return midori_bookmarks_db_array_from_statement (stmt, bookmarks);
+}
+
+/**
+ * midori_bookmarks_db_query_recursive:
  * @array: the main bookmark array
  * @fields: comma separated list of fields
  * @condition: condition, like "folder = '%q'"
@@ -514,38 +984,35 @@
  *
  * Return value: a #KatzeArray on success, %NULL otherwise
  *
- * Since: 0.4.4
+ * Since: 0.5.2
  **/
 KatzeArray*
-midori_array_query_recursive (KatzeArray*  bookmarks,
-                              const gchar* fields,
-                              const gchar* condition,
-                              const gchar* value,
-                              gboolean     recursive)
+midori_bookmarks_db_query_recursive (MidoriBookmarksDb*  bookmarks,
+                                  const gchar* fields,
+                                  const gchar* condition,
+                                  const gchar* value,
+                                  gboolean     recursive)
 {
-    sqlite3* db;
     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 (IS_MIDORI_BOOKMARKS_DB (bookmarks), NULL);
     g_return_val_if_fail (fields, NULL);
     g_return_val_if_fail (condition, NULL);
-    db = g_object_get_data (G_OBJECT (bookmarks), "db");
-    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);
     if (strstr (condition, "%q"))
     {
         sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
-        array = katze_array_from_sqlite (db, sqlcmd_value);
+        array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd_value);
         sqlite3_free (sqlcmd_value);
     }
     else
-        array = katze_array_from_sqlite (db, sqlcmd);
+        array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd);
     g_free (sqlcmd);
 
     if (!recursive)
@@ -556,9 +1023,9 @@
         if (KATZE_ITEM_IS_FOLDER (item))
         {
             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);
+                                               katze_item_get_meta_integer (item, "id"));
+            KatzeArray* subarray = midori_bookmarks_db_query_recursive (bookmarks,
+                                                                        fields, "parentid=%q", parentid, TRUE);
             KatzeItem* subitem;
             GList* sublist;
 
@@ -576,21 +1043,21 @@
 }
 
 static gint64
-count_from_sqlite (sqlite3*     db,
-		   const gchar* sqlcmd)
+midori_bookmarks_db_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);
+        count = sqlite3_column_int64(stmt, 0);
 
     sqlite3_clear_bindings (stmt);
     sqlite3_reset (stmt);
@@ -599,14 +1066,13 @@
 }
 
 static gint64
-midori_array_count_recursive_by_id (KatzeArray*  bookmarks,
-				    const gchar* condition,
-				    const gchar* value,
-				    gint64       id,
-				    gboolean     recursive)
+midori_bookmarks_db_count_recursive_by_id (MidoriBookmarksDb*  bookmarks,
+                                           const gchar*        condition,
+                                           const gchar*        value,
+                                           gint64              id,
+                                           gboolean            recursive)
 {
     gint64 count = -1;
-    sqlite3* db;
     gchar* sqlcmd;
     char* sqlcmd_value;
     sqlite3_stmt* stmt;
@@ -615,30 +1081,29 @@
     GList* iter_ids;
 
     g_return_val_if_fail (condition, -1);
-    g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), -1);
-    db = g_object_get_data (G_OBJECT (bookmarks), "db");
-    g_return_val_if_fail (db != NULL, -1);
+    g_return_val_if_fail (MIDORI_BOOKMARKS_DB (bookmarks), -1);
+    g_return_val_if_fail (bookmarks->db != NULL, -1);
 
     g_assert(!strstr("parentid", condition));
 
     if (id > 0)
-	sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
-				  "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
-				  id,
-				  condition);
+        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);
+        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);
+        count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd_value);
         sqlite3_free (sqlcmd_value);
     }
     else
-        count = count_from_sqlite (db, sqlcmd);
+        count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd);
 
     g_free (sqlcmd);
 
@@ -648,28 +1113,28 @@
     ids = NULL;
 
     if (id > 0)
-	sqlcmd_value = sqlite3_mprintf (
-	    "SELECT id FROM bookmarks "
-	    "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
+        sqlcmd_value = sqlite3_mprintf (
+            "SELECT id FROM bookmarks "
+            "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
     else
-	sqlcmd_value = sqlite3_mprintf (
-	    "SELECT id FROM bookmarks "
-	    "WHERE parentid IS NULL AND uri = ''");
+        sqlcmd_value = sqlite3_mprintf (
+            "SELECT id FROM bookmarks "
+            "WHERE parentid IS NULL AND uri = ''");
 
-    if (sqlite3_prepare_v2 (db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
+    if (sqlite3_prepare_v2 (bookmarks->db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
     {
-	g_assert (sqlite3_column_count (stmt) == 1);
-    
-	if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
-	{
-	    gint64* pid = g_new (gint64, 1);
-	    
-	    *pid = sqlite3_column_int64(stmt, 0);
-	    ids = g_list_append (ids, pid);
-	}
-	
-	sqlite3_clear_bindings (stmt);
-	sqlite3_reset (stmt);
+        g_assert (sqlite3_column_count (stmt) == 1);
+
+        if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
+        {
+            gint64* pid = g_new (gint64, 1);
+
+            *pid = sqlite3_column_int64(stmt, 0);
+            ids = g_list_append (ids, pid);
+        }
+
+        sqlite3_clear_bindings (stmt);
+        sqlite3_reset (stmt);
     }
 
     sqlite3_free (sqlcmd_value);
@@ -677,29 +1142,29 @@
     iter_ids = ids;
     while (iter_ids)
     {
-	gint64 sub_count = midori_array_count_recursive_by_id (bookmarks,
-							       condition,
-							       value,
-							       *(gint64*)(iter_ids->data),
-							       recursive);
-	
-	if (sub_count < 0)
-	{
-	    g_list_free_full (ids, g_free);
-	    return -1;
-	}
-	
-	count += sub_count;
-	iter_ids = g_list_next (iter_ids);
+        gint64 sub_count = midori_bookmarks_db_count_recursive_by_id (bookmarks,
+                                                                      condition,
+                                                                      value,
+                                                                      *(gint64*)(iter_ids->data),
+                                                                      recursive);
+
+        if (sub_count < 0)
+        {
+            g_list_free_full (ids, g_free);
+            return -1;
+        }
+
+        count += sub_count;
+        iter_ids = g_list_next (iter_ids);
     }
-	
+
     g_list_free_full (ids, g_free);
     return count;
 }
 
 /**
- * midori_array_count_recursive:
- * @array: the main bookmark array
+ * midori_bookmarks_db_count_recursive:
+ * @bookmarks: the main bookmark array
  * @condition: condition, like "folder = '%q'"
  * @value: a value to be inserted if @condition contains %q
  * @recursive: if %TRUE include children
@@ -709,19 +1174,19 @@
  * Since: 0.5.2
  **/
 gint64
-midori_array_count_recursive (KatzeArray*  bookmarks,
-			      const gchar* condition,
-                              const gchar* value,
-			      KatzeItem*   folder,
-                              gboolean     recursive)
+midori_bookmarks_db_count_recursive (MidoriBookmarksDb*  bookmarks,
+                                     const gchar*        condition,
+                                     const gchar*        value,
+                                     KatzeItem*          folder,
+                                     gboolean            recursive)
 {
     gint64 id = -1;
 
     g_return_val_if_fail (!folder || KATZE_ITEM_IS_FOLDER (folder), -1);
-    
+
     id = folder ? katze_item_get_meta_integer (folder, "id") : 0;
 
-    return midori_array_count_recursive_by_id (bookmarks, condition,
-					       value, id,
-					       recursive);
+    return midori_bookmarks_db_count_recursive_by_id (bookmarks, condition,
+                                                      value, id,
+                                                      recursive);
 }
 
=== modified file 'midori/midori-bookmarks-db.h'
--- midori/midori-bookmarks-db.h	2013-09-08 10:53:32 +0000
+++ midori/midori-bookmarks-db.h	2013-09-17 19:35:27 +0000
@@ -16,33 +16,60 @@
 #include <sqlite3.h>
 #include <katze/katze.h>
 
-KatzeArray*
-midori_bookmarks_new (char** errmsg);
-
-void
-midori_bookmarks_on_quit (KatzeArray* array);
-
-void
-midori_array_update_item (KatzeArray* bookmarks, KatzeItem* item);
-
-void
-midori_bookmarks_import_array (KatzeArray* bookmarks,
-                               KatzeArray* array,
-                               gint64      parentid);
-
-KatzeArray*
-midori_array_query_recursive (KatzeArray*  bookmarks,
-			      const gchar* fields,
-			      const gchar* condition,
-			      const gchar* value,
-			      gboolean     recursive);
+G_BEGIN_DECLS
+
+#define TYPE_MIDORI_BOOKMARKS_DB \
+    (midori_bookmarks_db_get_type ())
+#define MIDORI_BOOKMARKS_DB(obj) \
+    (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDb))
+#define MIDORI_BOOKMARKS_DB_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDbClass))
+#define IS_MIDORI_BOOKMARKS_DB(obj) \
+    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MIDORI_BOOKMARKS_DB))
+#define IS_MIDORI_BOOKMARKS_DB_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MIDORI_BOOKMARKS_DB))
+#define MIDORI_BOOKMARKS_DB_GET_CLASS(obj) \
+    (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDbClass))
+
+typedef struct _MidoriBookmarksDb                       MidoriBookmarksDb;
+typedef struct _MidoriBookmarksDbClass                  MidoriBookmarksDbClass;
+
+GType
+midori_bookmarks_db_get_type               (void) G_GNUC_CONST;
+
+MidoriBookmarksDb*
+midori_bookmarks_db_new (char** errmsg);
+
+void
+midori_bookmarks_db_on_quit (MidoriBookmarksDb* array);
+
+void
+midori_bookmarks_db_add_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
+
+void
+midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
+
+void
+midori_bookmarks_db_remove_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
+
+void
+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
+                                  KatzeArray* array,
+                                  gint64      parentid);
+
+KatzeArray*
+midori_bookmarks_db_query_recursive (MidoriBookmarksDb*  bookmarks,
+                                     const gchar* fields,
+                                     const gchar* condition,
+                                     const gchar* value,
+                                     gboolean     recursive);
 
 gint64
-midori_array_count_recursive (KatzeArray*  bookmarks,
-			      const gchar*        condition,
-			      const gchar*        value,
-			      KatzeItem*          folder,
-			      gboolean            recursive);
+midori_bookmarks_db_count_recursive (MidoriBookmarksDb*  bookmarks,
+				     const gchar*        condition,
+                                     const gchar*        value,
+				     KatzeItem*          folder,
+				     gboolean            recursive);
 
 gint64
 midori_bookmarks_insert_item_db (sqlite3*   db,
 
=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-09-16 22:00:41 +0000
+++ midori/midori-browser.c	2013-09-17 19:35:27 +0000
@@ -87,7 +87,7 @@
 
     MidoriWebSettings* settings;
     KatzeArray* proxy_array;
-    KatzeArray* bookmarks;
+    MidoriBookmarksDb* bookmarks;
     KatzeArray* trash;
     KatzeArray* search_engines;
     KatzeArray* history;
@@ -195,8 +195,8 @@
                                 GtkToolbarStyle style);
 
 static void
-midori_browser_set_bookmarks (MidoriBrowser* browser,
-                              KatzeArray*    bookmarks);
+midori_browser_set_bookmarks (MidoriBrowser*     browser,
+                              MidoriBookmarksDb* bookmarks);
 
 static void
 midori_browser_add_speed_dial (MidoriBrowser* browser);
@@ -863,7 +863,7 @@
 }
 
 static GtkWidget*
-midori_bookmark_folder_button_new (KatzeArray* array,
+midori_bookmark_folder_button_new (MidoriBookmarksDb* array,
                                    gint64      selected_parentid)
 {
     GtkTreeStore* model;
@@ -1231,18 +1231,9 @@
         katze_item_set_meta_integer (bookmark, "parentid", selected);
 
         if (new_bookmark)
-            katze_array_add_item (browser->bookmarks, bookmark);
+            midori_bookmarks_db_add_item (browser->bookmarks, bookmark);
         else
-	{
-            midori_array_update_item (browser->bookmarks, bookmark);
-	    midori_browser_update_history (bookmark, "bookmark", "modify");
-
-	    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_toolbar)))
-		if (!gtk_widget_get_visible (browser->bookmarkbar))
-		    _action_set_active (browser, "Bookmarkbar", TRUE);
-	    if (gtk_widget_get_visible (browser->bookmarkbar))
-		midori_bookmarkbar_populate (browser);
-	}
+            midori_bookmarks_db_update_item (browser->bookmarks, bookmark);
 
         return_status = TRUE;
     }
@@ -2545,7 +2536,7 @@
                                      "bookmarks",
                                      "Bookmarks",
                                      "The bookmarks folder, containing all bookmarks",
-                                     KATZE_TYPE_ARRAY,
+                                     TYPE_MIDORI_BOOKMARKS_DB,
                                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
     /**
@@ -3273,8 +3264,8 @@
     else
         condition = "parentid = %q";
 
-    bookmarks = midori_array_query_recursive  (browser->bookmarks,
-						 "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
+    bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
+        "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
     if (!bookmarks)
         return FALSE;
 
@@ -4308,7 +4299,7 @@
     KatzeItem* item;
 
     item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
-    katze_array_remove_item (browser->bookmarks, item);
+    midori_bookmarks_db_remove_item (browser->bookmarks, item);
 }
 
 static void
@@ -4320,7 +4311,7 @@
     MidoriContextAction* menu = midori_context_action_new ("BookmarkContextMenu", NULL, NULL, NULL);
     if (KATZE_ITEM_IS_FOLDER (item))
     {
-        gint child_bookmarks_count = midori_array_count_recursive (browser->bookmarks,
+        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (browser->bookmarks,
             "uri <> ''", NULL, item, FALSE);
 
         GtkAction* action = gtk_action_new ("BookmarkOpenAllTabs", _("Open all in _Tabs"), NULL, STOCK_TAB_NEW);
@@ -4590,8 +4581,7 @@
             if (error)
                 g_error_free (error);
         }
-        midori_bookmarks_import_array (browser->bookmarks, bookmarks, selected);
-
+        midori_bookmarks_db_import_array (browser->bookmarks, bookmarks, selected);
         g_object_unref (bookmarks);
         g_free (path);
     }
@@ -4645,7 +4635,7 @@
         return;
 
     error = NULL;
-    bookmarks = midori_array_query_recursive (browser->bookmarks,
+    bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
         "*", "parentid IS NULL", NULL, TRUE);
     if (!midori_array_to_file (bookmarks, path, format, &error))
     {
@@ -7060,6 +7050,16 @@
 }
 
 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)
@@ -7091,8 +7091,8 @@
     gtk_toolbar_insert (GTK_TOOLBAR (browser->bookmarkbar),
                         gtk_separator_tool_item_new (), -1);
 
-    array = midori_array_query_recursive  (browser->bookmarks,
-					     "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
+    array = midori_bookmarks_db_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);
@@ -7132,7 +7132,7 @@
 
 static void
 midori_browser_set_bookmarks (MidoriBrowser* browser,
-                              KatzeArray*    bookmarks)
+                              MidoriBookmarksDb*    bookmarks)
 {
     MidoriWebSettings* settings;
 
@@ -7141,6 +7141,8 @@
         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);
     }
 
@@ -7174,6 +7176,8 @@
     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-frontend.c'
--- midori/midori-frontend.c	2013-09-08 11:09:40 +0000
+++ midori/midori-frontend.c	2013-09-17 19:35:27 +0000
@@ -487,9 +487,9 @@
     }
     g_free (uri);
 
-    KatzeArray* bookmarks;
+    MidoriBookmarksDb* bookmarks;
     gchar* errmsg = NULL;
-    if (!(bookmarks = midori_bookmarks_new (&errmsg)))
+    if (!(bookmarks = midori_bookmarks_db_new (&errmsg)))
     {
         g_string_append_printf (error_messages,
             _("Bookmarks couldn't be loaded: %s\n"), errmsg);
@@ -596,11 +596,11 @@
 midori_normal_app_on_quit (MidoriApp* app)
 {
     MidoriWebSettings* settings = katze_object_get_object (app, "settings");
-    KatzeArray* bookmarks = katze_object_get_object (app, "bookmarks");
+    MidoriBookmarksDb* bookmarks = katze_object_get_object (app, "bookmarks");
     KatzeArray* history = katze_object_get_object (app, "history");
 
     g_object_notify (G_OBJECT (settings), "load-on-startup");
-    midori_bookmarks_on_quit (bookmarks);
+    midori_bookmarks_db_on_quit (bookmarks);
     midori_history_on_quit (history, settings);
     midori_private_data_on_quit (settings);
 
 
=== modified file 'panels/midori-bookmarks.c'
--- panels/midori-bookmarks.c	2013-09-08 11:09:40 +0000
+++ panels/midori-bookmarks.c	2013-09-17 19:35:27 +0000
@@ -45,7 +45,7 @@
     GtkWidget* delete;
     GtkWidget* treeview;
     MidoriApp* app;
-    KatzeArray* array;
+    MidoriBookmarksDb* bookmarks_db;
 
     gint filter_timeout;
     gchar* filter;
@@ -125,6 +125,7 @@
     return STOCK_BOOKMARKS;
 }
 
+#if 0 /* Make sure the following function is never used */
 /* TODO: Function never used */
 void
 midori_bookmarks_export_array_db (sqlite3*    db,
@@ -138,7 +139,7 @@
     gchar* parent_id;
 
     parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-    if (!(root_array = midori_array_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
+    if (!(root_array = midori_bookmarks_db_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
     {
         g_free (parent_id);
         return;
@@ -160,6 +161,7 @@
     g_free (parent_id);
     g_list_free (list);
 }
+#endif /* 0 */
 
 static KatzeArray*
 midori_bookmarks_read_from_db (MidoriBookmarks* bookmarks,
@@ -169,21 +171,21 @@
     KatzeArray* array;
 
     if (keyword && *keyword)
-        array = midori_array_query_recursive  (bookmarks->array,
-				    "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
+        array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
+                                                     "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
     else
     {
         if (parentid > 0)
         {
             gchar* parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
-            array = midori_array_query_recursive  (bookmarks->array,
-					"id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
+            array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
+                                                         "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
 
             g_free (parent_id);
         }
         else
-            array = midori_array_query_recursive (bookmarks->array,
-						  "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
+            array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
+                                                         "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
     }
     return array ? array : katze_array_new (KATZE_TYPE_ITEM);
 }
@@ -274,9 +276,9 @@
     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);
+
+    midori_bookmarks_db_update_item (bookmarks->bookmarks_db, item);
 
     g_object_unref (item);
     if (new_parent)
@@ -416,9 +418,9 @@
 
         if (KATZE_ITEM_IS_FOLDER (item))
         {
-            gint child_folders_count = midori_array_count_recursive (bookmarks->array,
+            gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
                 "uri = ''", NULL, item, FALSE);
-            gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
+            gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
                 "uri <> ''", NULL, item, FALSE);
             gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
             gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
@@ -451,9 +453,9 @@
     }
     else
     {
-        gint child_folders_count = midori_array_count_recursive (bookmarks->array,
+        gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri = ''", NULL, NULL, FALSE);
-        gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
+        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri <> ''", NULL, NULL, FALSE);
         gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
         gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
@@ -499,10 +501,10 @@
 
         /* 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,
+        g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
             midori_bookmarks_remove_item_cb, bookmarks);
-        katze_array_remove_item (bookmarks->array, item);
-        g_signal_handlers_unblock_by_func (bookmarks->array,
+        midori_bookmarks_db_remove_item (bookmarks->bookmarks_db, item);
+        g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
             midori_bookmarks_remove_item_cb, bookmarks);
         g_object_unref (item);
     }
@@ -585,9 +587,9 @@
     GtkTreeModel* model;
 
     model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
-    if (bookmarks->array)
+    if (bookmarks->bookmarks_db)
     {
-        g_object_unref (bookmarks->array);
+        g_object_unref (bookmarks->bookmarks_db);
         gtk_tree_store_clear (GTK_TREE_STORE (model));
     }
     katze_assign (bookmarks->app, app);
@@ -595,13 +597,13 @@
         return;
 
     g_object_ref (app);
-    bookmarks->array = katze_object_get_object (app, "bookmarks");
+    bookmarks->bookmarks_db = katze_object_get_object (app, "bookmarks");
     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 (bookmarks->array, "remove-item",
+    g_signal_connect_after (bookmarks->bookmarks_db, "add-item",
+                            G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
+    g_signal_connect (bookmarks->bookmarks_db, "remove-item",
                       G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
-    g_signal_connect (bookmarks->array, "update",
+    g_signal_connect (bookmarks->bookmarks_db, "update",
                       G_CALLBACK (midori_bookmarks_update_cb), bookmarks);
     g_signal_connect_after (model, "row-changed",
                             G_CALLBACK (midori_bookmarks_row_changed_cb),
@@ -835,7 +837,7 @@
     menu = gtk_menu_new ();
     if (KATZE_ITEM_IS_FOLDER (item))
     {
-        gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
+        gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
             "uri <> ''", NULL, item, FALSE);
 
         midori_bookmarks_popup_item (menu,
 
=== modified file 'tests/bookmarks.c'
--- tests/bookmarks.c	2012-11-25 15:37:41 +0000
+++ tests/bookmarks.c	2013-09-17 19:35:27 +0000
@@ -10,11 +10,11 @@
  */
 
 #include "midori.h"
-#include "panels/midori-bookmarks.h"
+#include "midori-bookmarks-db.h"
 
 typedef struct
 {
-    KatzeArray* db_bookmarks;
+    MidoriBookmarksDb* db_bookmarks;
     KatzeArray* test_bookmarks;
 } BookmarksFixture;
 
@@ -37,7 +37,7 @@
     KatzeArray* folder;
     gchar *errmsg = NULL;
 
-    if (!(fixture->db_bookmarks = midori_bookmarks_new (&errmsg)))
+    if (!(fixture->db_bookmarks = midori_bookmarks_db_new (&errmsg)))
         g_error ("Bookmarks couldn't be loaded: %s\n", errmsg);
     g_assert (errmsg == NULL);
     g_assert (g_object_get_data (G_OBJECT (fixture->db_bookmarks), "db"));
@@ -84,8 +84,8 @@
 fixture_teardown (BookmarksFixture* fixture,
                   const TestParameters *params)
 {
-    midori_bookmarks_on_quit (fixture->db_bookmarks);
-    g_object_unref (fixture->db_bookmarks);
+    midori_bookmarks_db_on_quit (fixture->db_bookmarks);
+    /* g_object_unref (fixture->db_bookmarks); */
     g_object_unref (fixture->test_bookmarks);
 }
 
@@ -112,7 +112,7 @@
 /* NB: assumes "title" is unique in a set */
 static void
 compare_test_and_db (KatzeArray* test_bookmarks,
-                     KatzeArray* db_bookmarks,
+                     MidoriBookmarksDb* db_bookmarks,
                      gboolean verbose)
 {
     KatzeArray* db_items;
@@ -127,7 +127,7 @@
             g_print ("----------\n");
         }
 
-        db_items = midori_array_query_recursive (db_bookmarks,
+        db_items = midori_bookmarks_db_query_recursive (db_bookmarks,
                            "*", "title='%q'", katze_item_get_name (test_item), FALSE);
 
         /* FIXME g_assert_cmpint (katze_array_get_length (db_items), ==, 1); */
@@ -142,28 +142,33 @@
 }
 
 static void
+print_bookmarks (KatzeArray* test_bookmarks)
+{
+    KatzeItem* item;
+    GList* list;
+    KATZE_ARRAY_FOREACH_ITEM_L (item, test_bookmarks, list)
+    {
+	print_bookmark (item);
+	g_print ("----------\n");
+
+        if (KATZE_ITEM_IS_FOLDER(item))
+            print_bookmarks (KATZE_ARRAY (item));
+    }
+    g_list_free (list);
+}
+
+static void
 insert_bookmarks (KatzeArray* test_bookmarks,
-                  KatzeArray* db_bookmarks,
+                  MidoriBookmarksDb* db_bookmarks,
                   gboolean verbose)
 {
-    KatzeItem* item;
-    GList* list;
-    sqlite3 *db = g_object_get_data (G_OBJECT (db_bookmarks), "db");
 
-    KATZE_ARRAY_FOREACH_ITEM_L (item, test_bookmarks, list)
+    if (verbose)
     {
-        if (verbose)
-        {
-            print_bookmark (item);
-            g_print ("----------\n");
-        }
-
-        midori_bookmarks_insert_item_db (db, item, 0);
-
-        if (KATZE_ITEM_IS_FOLDER(item))
-            insert_bookmarks (KATZE_ARRAY (item), db_bookmarks, verbose);
+	print_bookmarks (test_bookmarks);
     }
-    g_list_free (list);
+
+    midori_bookmarks_db_import_array (db_bookmarks, test_bookmarks, 0);
 }
 
 static void