Merge lp:~aauzi/midori/fix-1177553-3 into lp:midori

[André Auzi]

Show folder tree when editing bookmarks

This last step for Bookmark folder tree reflection addresses the bookmarks edit dialog combo box.

The combo box is reworked to display a tree view of the bookmark folders.

Folder icons are added and give, in the combo box, a display of folders that aims to have consistent aspect with bookmark bar, bookmark menu and bookmark panel.

The combo box population algorithm is reworked to handle the case of sub-folders referring to a previously populated parent folder.

After this process, remaining items of the retrieved folders list are orphaned folder entries.

Opened folder are now displayed with the message 'Select [folder name]'.

[Cris Dywan (kalikiana)]

I could live with the "duplicate" folder if need be. If it's feasible I'd consider renaming the "second" menu item to "Choose this folder", a style I've seen in a few places.
For the sizing, sokoke.c has a function, alternatively something screen width based. Hard to say which works best in this case honestly.

review: Needs Fixing

[Cris Dywan (kalikiana)]

Could you provide some reasoning as to what the 2 new classes offer over standard cell renderers?

review: Needs Information

[André Auzi (aauzi)]

> Could you provide some reasoning as to what the 2 new classes offer over
> standard cell renderers?

Sure.

The combobox uses the same tree store row for the folder and the top menuitem it presents, before the separator, in the subfolder list view.

That's why we get the same name and icons in the opened folder and the top menuitem of the subfolders list.

I had to figure out a way to distinguish between the two situations:
a/ when the rendered row corresponds to the folder
b/ when the rendered row corresponds to the top of subfolders list

Since the cell renderers are executed on the same row this could not be done by information stored in the row itself.

The cell renderers I've (rapidly) written examine the containing menu to determine if they're called on a the first widget of a menu, just before a separator.

This could had been avoided for pixbufs if the combobox managed the 'expanded' property of the cell renderer, as a treeview does, but, unless I've made a big mistake, it does not seem to do it. (I couldn't make it work :/)

The two new classes are actually tied to the combobox implementation and offer the capability to render different text and pixbufs for the folder when it's listed in a menu or presented at the top of it's containees.

Note: since the detection is the same for the two classes I believe they can be implemented with about half of the code I used here.

Honestly, if combobox on tree store is not used elsewhere, I would be reluctant to keep them.

I'd only provide them if negative user feedback was given on the previous, straight forward, implementation.

[Cris Dywan (kalikiana)]

I'm fine with the approach, purely technically speaking.

review: Approve

[Paweł Forysiuk (tuxator)]

Seems to work fine. Approve

review: Approve

=== added file 'katze/katze-cellrenderercomboboxtext.c'
--- katze/katze-cellrenderercomboboxtext.c	1970-01-01 00:00:00 +0000
+++ katze/katze-cellrenderercomboboxtext.c	2013-07-27 21:58:26 +0000
@@ -0,0 +1,518 @@
+/*
+ Copyright (C) 2008-2013 Christian Dywan <[e-mail]>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ See the file COPYING for the full license text.
+*/
+
+#include "katze-cellrenderercomboboxtext.h"
+
+#include "marshal.h"
+
+#include <string.h>
+#include <gdk/gdk.h>
+
+#define P_(String) (String)
+#define I_(String) (String)
+#define GTK_PARAM_READABLE G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+#define GTK_PARAM_WRITABLE G_PARAM_WRITABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+#define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+
+
+static void
+katze_cell_renderer_combobox_text_finalize (GObject* object);
+
+static void
+katze_cell_renderer_combobox_text_get_property (GObject*    object,
+    guint       param_id,
+    GValue*     value,
+    GParamSpec* pspec);
+static void
+katze_cell_renderer_combobox_text_set_property (GObject*      object,
+    guint         param_id,
+    const GValue* value,
+    GParamSpec*   pspec);
+static void
+katze_cell_renderer_combobox_text_get_size (GtkCellRenderer* cell,
+    GtkWidget*       widget,
+    GdkRectangle*    cell_area,
+    gint*            x_offset,
+    gint*            y_offset,
+    gint*            width,
+    gint*            height);
+#if GTK_CHECK_VERSION(3,0,0)
+static void
+katze_cell_renderer_combobox_text_render (GtkCellRenderer      *cell,
+    cairo_t*             cr,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GtkCellRendererState  flags);
+#else
+static void
+katze_cell_renderer_combobox_text_render (GtkCellRenderer      *cell,
+    GdkDrawable          *window,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GdkRectangle         *expose_area,
+    GtkCellRendererState  flags);
+#endif
+
+static void
+(*_cell_renderer_get_size) (GtkCellRenderer* cell,
+    GtkWidget*       widget,
+    GdkRectangle*    cell_area,
+    gint*            x_offset,
+    gint*            y_offset,
+    gint*            width,
+    gint*            height);
+
+#if GTK_CHECK_VERSION(3,0,0)
+static void
+(*_cell_renderer_render) (GtkCellRenderer      *cell,
+    cairo_t*             cr,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GtkCellRendererState  flags) = NULL;
+#else
+static void
+(*_cell_renderer_render) (GtkCellRenderer      *cell,
+    GdkDrawable          *window,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GdkRectangle         *expose_area,
+    GtkCellRendererState  flags) = NULL;
+#endif
+
+enum {
+    PROP_0,
+
+    PROP_FOLDED_TEXT,
+    PROP_FOLDED_MARKUP,
+    PROP_FOLDED_ATTRIBUTES,
+    PROP_UNFOLDED_TEXT,
+    PROP_UNFOLDED_MARKUP,
+    PROP_UNFOLDED_ATTRIBUTES,
+};
+
+#define KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT, KatzeCellRendererComboBoxTextPrivate))
+
+typedef struct _KatzeCellRendererComboBoxTextPrivate KatzeCellRendererComboBoxTextPrivate;
+struct _KatzeCellRendererComboBoxTextPrivate
+{
+    struct _Properties {
+        PangoAttrList* extra_attrs;
+
+        gchar* text;
+
+        guint markup_set : 1;
+    } props[2];
+};
+
+G_DEFINE_TYPE (KatzeCellRendererComboBoxText, katze_cell_renderer_combobox_text, GTK_TYPE_CELL_RENDERER_TEXT)
+
+static void
+katze_cell_renderer_combobox_text_init (KatzeCellRendererComboBoxText *celltext)
+{
+    guint prop_index;
+    KatzeCellRendererComboBoxTextPrivate *priv;
+
+    priv = KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_PRIVATE (celltext);
+
+    for (prop_index = 0 ; prop_index < 2; prop_index++)
+    {
+        priv->props[prop_index].text = NULL;
+        priv->props[prop_index].extra_attrs = NULL;
+        priv->props[prop_index].markup_set = FALSE;
+    }
+}
+
+static void
+katze_cell_renderer_combobox_text_class_init (KatzeCellRendererComboBoxTextClass *class)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (class);
+    GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
+
+    object_class->finalize = katze_cell_renderer_combobox_text_finalize;
+
+    _cell_renderer_get_size = cell_class->get_size;
+    _cell_renderer_render = cell_class->render;
+
+    object_class->get_property = katze_cell_renderer_combobox_text_get_property;
+    object_class->set_property = katze_cell_renderer_combobox_text_set_property;
+
+    cell_class->get_size = katze_cell_renderer_combobox_text_get_size;
+    cell_class->render = katze_cell_renderer_combobox_text_render;
+
+    g_object_class_install_property (object_class,
+        PROP_FOLDED_TEXT,
+        g_param_spec_string ("folded-text",
+            P_("Folded text"),
+            P_("Text to render if combobox_text is closed. The string [text] is replaced by default text"),
+            NULL,
+            GTK_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+        PROP_FOLDED_MARKUP,
+        g_param_spec_string ("folded-markup",
+            P_("Folded markup"),
+            P_("Marked up text to render if combobox_text is closed. The string [text] is replaced by default text"),
+            NULL,
+            GTK_PARAM_WRITABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_FOLDED_ATTRIBUTES,
+        g_param_spec_boxed ("folded-attributes",
+            P_("Folded attributes"),
+            P_("A list of style attributes to apply to the text of the renderer if combobox_text is closed"),
+            PANGO_TYPE_ATTR_LIST,
+            GTK_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+        PROP_UNFOLDED_TEXT,
+        g_param_spec_string ("unfolded-text",
+            P_("Unfolded text"),
+            P_("Text to render if combobox_text is opened"),
+            NULL,
+            GTK_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+        PROP_UNFOLDED_MARKUP,
+        g_param_spec_string ("unfolded-markup",
+            P_("Unfolded markup"),
+            P_("Marked up text to render if combobox_text is opened"),
+            NULL,
+            GTK_PARAM_WRITABLE));
+
+    g_object_class_install_property (object_class,
+        PROP_UNFOLDED_ATTRIBUTES,
+        g_param_spec_boxed ("unfolded-attributes",
+            P_("Unfolded attributes"),
+            P_("A list of style attributes to apply to the text of the renderer if combobox_text is opened"),
+            PANGO_TYPE_ATTR_LIST,
+            GTK_PARAM_READWRITE));
+
+
+    g_type_class_add_private (object_class, sizeof (KatzeCellRendererComboBoxTextPrivate));
+}
+
+static void
+katze_cell_renderer_combobox_text_finalize (GObject *object)
+{
+    guint prop_index;
+    KatzeCellRendererComboBoxTextPrivate *priv;
+
+    priv = KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_PRIVATE (object);
+
+    for (prop_index = 0 ; prop_index < 2; prop_index++)
+    {
+        g_free (priv->props[prop_index].text);
+        if (priv->props[prop_index].extra_attrs)
+            pango_attr_list_unref (priv->props[prop_index].extra_attrs);
+    }
+
+    G_OBJECT_CLASS (katze_cell_renderer_combobox_text_parent_class)->finalize (object);
+}
+
+static void
+katze_cell_renderer_combobox_text_get_property (GObject*    object,
+					 guint       param_id,
+					 GValue*     value,
+					 GParamSpec* pspec)
+{
+    KatzeCellRendererComboBoxTextPrivate *priv;
+
+    priv = KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_PRIVATE (object);
+
+    switch (param_id)
+    {
+        case PROP_FOLDED_TEXT:
+            g_value_set_string (value, priv->props[0].text);
+            break;
+
+        case PROP_FOLDED_ATTRIBUTES:
+            g_value_set_boxed (value, priv->props[0].extra_attrs);
+            break;
+
+        case PROP_UNFOLDED_TEXT:
+            g_value_set_string (value, priv->props[1].text);
+            break;
+
+        case PROP_UNFOLDED_ATTRIBUTES:
+            g_value_set_boxed (value, priv->props[1].extra_attrs);
+            break;
+
+        case PROP_FOLDED_MARKUP:
+        case PROP_UNFOLDED_MARKUP:
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+            break;
+    }
+}
+
+
+static void
+katze_cell_renderer_combobox_text_set_property (GObject*      object,
+					 guint         param_id,
+					 const GValue* value,
+					 GParamSpec*   pspec)
+{
+    guint prop_index = 0;
+    KatzeCellRendererComboBoxTextPrivate *priv;
+
+    priv = KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_PRIVATE (object);
+
+    switch (param_id)
+    {
+        case PROP_FOLDED_TEXT:
+        prop_text:
+            g_free (priv->props[prop_index].text);
+
+            if (priv->props[prop_index].markup_set)
+            {
+                if (priv->props[prop_index].extra_attrs)
+                {
+                    pango_attr_list_unref (priv->props[prop_index].extra_attrs);
+                    priv->props[prop_index].extra_attrs = NULL;
+                }
+                priv->props[prop_index].markup_set = FALSE;
+            }
+
+            priv->props[prop_index].text = g_value_dup_string (value);
+            break;
+
+        case PROP_FOLDED_ATTRIBUTES:
+        prop_attributes:
+            if (priv->props[prop_index].extra_attrs)
+                pango_attr_list_unref (priv->props[prop_index].extra_attrs);
+
+            priv->props[prop_index].extra_attrs = g_value_get_boxed (value);
+            if (priv->props[prop_index].extra_attrs)
+                pango_attr_list_ref (priv->props[prop_index].extra_attrs);
+            break;
+
+        case PROP_FOLDED_MARKUP:
+        prop_markup:
+        {
+            const gchar *str;
+            gchar *text = NULL;
+            GError *error = NULL;
+            PangoAttrList *attrs = NULL;
+
+            str = g_value_get_string (value);
+            if (str && !pango_parse_markup (str,
+					-1,
+					0,
+					&attrs,
+					&text,
+					NULL,
+					&error))
+            {
+                g_warning ("Failed to set text from markup due to error parsing markup: %s",
+                    error->message);
+                g_error_free (error);
+                return;
+            }
+
+            g_free (priv->props[prop_index].text);
+
+            if (priv->props[prop_index].extra_attrs)
+                pango_attr_list_unref (priv->props[prop_index].extra_attrs);
+
+            priv->props[prop_index].text = text;
+            priv->props[prop_index].extra_attrs = attrs;
+            priv->props[prop_index].markup_set = TRUE;
+        }
+        break;
+
+        case PROP_UNFOLDED_TEXT:
+            prop_index = 1;
+            goto prop_text;
+
+        case PROP_UNFOLDED_ATTRIBUTES:
+            prop_index = 1;
+            goto prop_attributes;
+
+        case PROP_UNFOLDED_MARKUP:
+            prop_index = 1;
+            goto prop_markup;
+
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+            break;
+    }
+}
+
+/**
+ * katze_cell_renderer_combobox_text_new:
+ *
+ * Creates a new #KatzeCellRendererComboBoxText. Adjust how text is drawn using
+ * object properties. Object properties can be
+ * set globally (with g_object_set()). Also, with #GtkTreeViewColumn,
+ * you can bind a property to a value in a #GtkTreeModel. For example,
+ * you can bind the "text" property on the cell renderer to a string
+ * value in the model, thus rendering a different string in each row
+ * of the #GtkTreeView
+ *
+ * Return value: the new cell renderer
+ **/
+GtkCellRenderer *
+katze_cell_renderer_combobox_text_new (void)
+{
+    return g_object_new (KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT, NULL);
+}
+
+static void
+set_text(KatzeCellRendererComboBoxText* cell,
+    GtkWidget* widget,
+    const gchar* repl)
+{
+    const gchar *text = NULL;
+    PangoAttrList* extra_attrs = NULL;
+    GtkWidget* pwidget = gtk_widget_get_parent (widget);
+    gboolean unfolded = FALSE;
+    KatzeCellRendererComboBoxTextPrivate *priv;
+
+    priv = KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_PRIVATE (cell);
+
+    if (GTK_IS_MENU_ITEM (pwidget))
+    {
+        GtkWidget* menu = gtk_widget_get_parent (pwidget);
+        GList* items;
+
+        if (menu
+            && (GTK_IS_MENU (menu))
+            && (items = gtk_container_get_children (GTK_CONTAINER (menu)))
+            && (GTK_WIDGET (items->data) == pwidget)
+            && (g_list_length (items) > 1)
+            && (GTK_IS_SEPARATOR_MENU_ITEM (g_list_next (items)->data)))
+        {
+            unfolded = TRUE;
+        }
+    }
+
+    if (unfolded)
+    {
+        text = priv->props[1].text;
+        extra_attrs = priv->props[1].extra_attrs;
+    }
+    else
+    {
+        text = priv->props[0].text;
+        extra_attrs = priv->props[0].extra_attrs;
+    }
+
+    if (!text)
+    {
+        text = g_strdup (repl ? repl : "");
+    }
+    else
+    {
+        GString* string = g_string_new ("");
+        const gchar* src = text;
+        const guint skip = sizeof ("[text]") - 1;
+        guint len;
+
+        while (0 != (len = strlen(src)))
+        {
+            const gchar* found = strstr (src, "[text]");
+
+            if (!found)
+            {
+                g_string_append (string, src);
+                src += len;
+            }
+            else
+            {
+                g_string_append_len (string, src, found-src);
+                if (repl)
+                    g_string_append (string, repl);
+                src = found + skip;
+            }
+        }
+
+        text = g_string_free (string, FALSE);
+    }
+
+    g_object_set (G_OBJECT (cell),
+        "text", text,
+        "attributes", extra_attrs,
+        NULL);
+
+    g_free ((gpointer)text);
+}
+
+static void
+katze_cell_renderer_combobox_text_get_size (GtkCellRenderer *cell,
+				 GtkWidget       *widget,
+				 GdkRectangle    *cell_area,
+				 gint            *x_offset,
+				 gint            *y_offset,
+				 gint            *width,
+				 gint            *height)
+{
+    const gchar *text = NULL;
+
+    g_object_get (G_OBJECT (cell), "text", &text, NULL);
+
+    set_text (KATZE_CELL_RENDERER_COMBOBOX_TEXT (cell), widget, text);
+
+    _cell_renderer_get_size (cell,
+        widget, cell_area,
+        x_offset, y_offset, width, height);
+
+    g_object_set (G_OBJECT (cell), "text", text, NULL);
+    g_free ((gpointer)text);
+}
+
+static void
+#if GTK_CHECK_VERSION(3,0,0)
+katze_cell_renderer_combobox_text_render (GtkCellRenderer      *cell,
+			       cairo_t*             cr,
+			       GtkWidget            *widget,
+			       GdkRectangle         *background_area,
+			       GdkRectangle         *cell_area,
+			       GtkCellRendererState  flags)
+#else
+katze_cell_renderer_combobox_text_render (GtkCellRenderer      *cell,
+			       GdkDrawable          *window,
+			       GtkWidget            *widget,
+			       GdkRectangle         *background_area,
+			       GdkRectangle         *cell_area,
+			       GdkRectangle         *expose_area,
+			       GtkCellRendererState  flags)
+#endif
+{
+    const gchar *text = NULL;
+
+    g_object_get (G_OBJECT (cell), "text", &text, NULL);
+
+    set_text (KATZE_CELL_RENDERER_COMBOBOX_TEXT (cell), widget, text);
+
+#if GTK_CHECK_VERSION(3,0,0)
+    _cell_renderer_render (cell,
+        cr,
+        widget,
+        background_area,
+        cell_area,
+        flags);
+#else
+    _cell_renderer_render (cell,
+        window,
+        widget,
+        background_area,
+        cell_area,
+        expose_area,
+        flags);
+#endif
+
+    g_object_set (G_OBJECT (cell), "text", text, NULL);
+    g_free ((gpointer)text);
+}
 
=== added file 'katze/katze-cellrenderercomboboxtext.h'
--- katze/katze-cellrenderercomboboxtext.h	1970-01-01 00:00:00 +0000
+++ katze/katze-cellrenderercomboboxtext.h	2013-07-27 21:58:26 +0000
@@ -0,0 +1,58 @@
+/*
+ Copyright (C) 2008-2013 Christian Dywan <[e-mail]>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ See the file COPYING for the full license text.
+*/
+
+#ifndef __KATZE_CELL_RENDERER_COMBOBOX_TEXT_H__
+#define __KATZE_CELL_RENDERER_COMBOBOX_TEXT_H__
+
+
+#include <gtk/gtk.h>
+
+#ifndef GSEAL
+#define GSEAL(String) String
+#endif
+
+G_BEGIN_DECLS
+
+
+#define KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT		(katze_cell_renderer_combobox_text_get_type ())
+#define KATZE_CELL_RENDERER_COMBOBOX_TEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT, KatzeCellRendererComboBoxText))
+#define KATZE_CELL_RENDERER_COMBOBOX_TEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT, KatzeCellRendererComboBoxTextClass))
+#define KATZE_IS_CELL_RENDERER_COMBOBOX_TEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT))
+#define KATZE_IS_CELL_RENDERER_COMBOBOX_TEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT))
+#define KATZE_CELL_RENDERER_COMBOBOX_TEXT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), KATZE_TYPE_CELL_RENDERER_COMBOBOX_TEXT, KatzeCellRendererComboBoxTextClass))
+
+typedef struct _KatzeCellRendererComboBoxText      KatzeCellRendererComboBoxText;
+typedef struct _KatzeCellRendererComboBoxTextClass KatzeCellRendererComboBoxTextClass;
+
+struct _KatzeCellRendererComboBoxText
+{
+  GtkCellRendererText parent;
+
+  /*< private >*/
+};
+
+struct _KatzeCellRendererComboBoxTextClass
+{
+  GtkCellRendererTextClass parent_class;
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GType            katze_cell_renderer_combobox_text_get_type (void) G_GNUC_CONST;
+GtkCellRenderer *katze_cell_renderer_combobox_text_new      (void);
+
+G_END_DECLS
+
+#endif /* __KATZE_CELL_RENDERER_COMBOBOX_TEXT_H__ */
 
=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-07-15 23:01:23 +0000
+++ midori/midori-browser.c	2013-07-27 21:58:26 +0000
@@ -26,6 +26,7 @@
 #include "midori-privatedata.h"
 #include "midori-core.h"
 #include "midori-privatedata.h"
+#include "katze-cellrenderercomboboxtext.h"
 
 #include "marshal.h"
 
@@ -828,52 +829,217 @@
     }
 }
 
+static gboolean
+midori_bookmark_folder_button_reach_parent (GtkTreeModel* model, GtkTreeIter *iter, gint64 parentid)
+{
+    do
+    {
+        gint64 id;
+
+        gtk_tree_model_get (model, iter, 1, &id, -1);
+
+        if (parentid == id)
+            return TRUE;
+
+        if (gtk_tree_model_iter_has_child (model, iter))
+        {
+            GtkTreeIter child;
+            gtk_tree_model_iter_children (model, &child, iter);
+            if (midori_bookmark_folder_button_reach_parent (model, &child, parentid))
+            {
+                *iter = child;
+                return TRUE;
+            }
+        }
+    }
+    while (gtk_tree_model_iter_next (model, iter));
+
+    return FALSE;
+}
+
+typedef struct _FolderEntry
+{
+    const gchar *title;
+    gint64 id;
+    gint64 parentid;
+} FolderEntry;
+
+static void
+midori_bookmark_folder_free_folder_entry (FolderEntry* folder)
+{
+    g_free ((gpointer)folder->title);
+}
+
 static GtkWidget*
 midori_bookmark_folder_button_new (KatzeArray* array,
-                                   gint64      selected,
-                                   gint64      parentid)
+                                   gint64      selected_parentid)
 {
-    GtkListStore* model;
+    GtkTreeStore* model;
     GtkWidget* combo;
     GtkCellRenderer* renderer;
     guint n;
     sqlite3* db;
     sqlite3_stmt* statement;
     gint result;
-    const gchar* sqlcmd = "SELECT title, id FROM bookmarks WHERE uri='' ORDER BY title ASC";
-
-    model = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT64);
-    combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
-    renderer = gtk_cell_renderer_text_new ();
-    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
-    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 0);
-    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "ellipsize", 1);
-    gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
-        0, _("Bookmarks"), 1, PANGO_ELLIPSIZE_END, 2, (gint64)0, -1);
-    gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
+    const gchar* sqlcmd = "SELECT title, id, parentid FROM bookmarks WHERE uri='' ORDER BY parentid, title ASC";
+    gint64 current_parentid;
+    GtkTreeIter tree_iter;
+    GtkTreeIter stock_parent_iter;
+    GtkTreeIter* parent_iter;
+    GList *folders = NULL;
 
     db = g_object_get_data (G_OBJECT (array), "db");
     g_return_val_if_fail (db != NULL, NULL);
+
+    /* folder combo box model content:
+    ** 0: title
+    ** 1: id
+    */
+    model = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT64);
+    combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
+
+    /* setup combo layout
+    ** 0: a folder icon
+    ** 1: the folder name
+     */
+
+    gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
+
+    renderer = gtk_cell_renderer_pixbuf_new ();
+    g_object_set (G_OBJECT (renderer), 
+        "stock-id", GTK_STOCK_DIRECTORY,
+        "stock-size", GTK_ICON_SIZE_MENU,
+        NULL);
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
+
+    renderer = katze_cell_renderer_combobox_text_new ();
+    g_object_set (G_OBJECT (renderer), 
+        "width-chars", 40,    /* FIXME: figure out a way to define an acceptable string length */
+        "ellipsize", PANGO_ELLIPSIZE_END,
+        "unfolded-text", _("Select [text]"),
+        NULL);
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
+    gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 0);
+
+    /* read the folders list from the database */
+    /* FIXME: this should be a service of midori/midori-bookmarks-db */
+
+    if ((result = sqlite3_prepare_v2 (db, sqlcmd, -1, &statement, NULL)) == SQLITE_OK)
+    {
+        while ((result = sqlite3_step (statement)) == SQLITE_ROW)
+        {
+            FolderEntry* folder = g_new (FolderEntry, 1);
+
+            folder->title = g_strdup ((const gchar*)sqlite3_column_text (statement, 0));
+            folder->id = sqlite3_column_int64 (statement, 1);
+            folder->parentid = sqlite3_column_int64 (statement, 2);
+
+            folders = g_list_append (folders, folder);
+        }
+
+       	sqlite3_clear_bindings (statement);
+        sqlite3_reset (statement);
+    }
+
+    /* populate the combo box */
+    /* FIXME: here we should have the root bookmark array's name and id, not hard encoded values */
+
+    gtk_tree_store_insert_with_values (model, &tree_iter, NULL, G_MAXINT,
+        0, _("Bookmarks"), 1, (gint64)0, -1);
+    gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &tree_iter);
+
+    current_parentid = 0;
+    parent_iter = NULL;
     n = 1;
-    if ((result = sqlite3_prepare_v2 (db, sqlcmd, -1, &statement, NULL)) == SQLITE_OK)
-    while ((result = sqlite3_step (statement)) == SQLITE_ROW)
+    while (g_list_first (folders))
     {
-        const unsigned char* name = sqlite3_column_text (statement, 0);
-        gint64 id = sqlite3_column_int64 (statement, 1);
+        gboolean something_done = FALSE;
+        GList* list_iter = g_list_first (folders);
 
-        /* do not show the folder itself */
-        if (id != selected)
+        do
         {
-            gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
-                0, name, 1, PANGO_ELLIPSIZE_END, 2, id, -1);
-
-            if (id == parentid)
-                gtk_combo_box_set_active (GTK_COMBO_BOX (combo), n);
+            FolderEntry* folder = list_iter->data;
+            const gchar* title = folder->title;
+            gint64 id = folder->id;
+            gint64 parentid = folder->parentid;
+
+            if (parentid != current_parentid)  /* optimize case of sub-folders of the same parent */
+            {
+                if (!parentid)
+                {
+                    /* folder's parent is the stree store root */
+
+                    current_parentid = 0;
+                    parent_iter = NULL;
+                }
+                else if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &tree_iter))
+                {
+                    if (midori_bookmark_folder_button_reach_parent (
+                            GTK_TREE_MODEL (model), &tree_iter, parentid))
+                    {
+                        /* folder's parent found in the tree store */
+
+                        current_parentid = parentid;
+                        stock_parent_iter = tree_iter;
+                        parent_iter = &stock_parent_iter;
+                    }
+                    else
+                    {
+                        /* folder's parent not found, skip it */
+
+                        list_iter = g_list_next (list_iter);
+                        continue;
+                    }
+                }
+                else
+                    g_assert_not_reached ();
+            }
+
+            /* insert folder in the tree store and remove it from the folders list */
+
+            gtk_tree_store_insert_with_values (model, &tree_iter, parent_iter, G_MAXINT,
+                0, title, 1, id, -1);
+
+            if (id == selected_parentid)
+                gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &tree_iter);
+
             n++;
-        }
-    }
+
+            something_done = TRUE;
+
+            g_free ((gpointer)title);
+            folders = g_list_delete_link (folders, list_iter);
+
+            list_iter = g_list_first (folders);
+        }
+        while (list_iter);
+
+        if (!something_done)  /* avoid infinite loop in case of orphan folders */
+            break;
+    }
+
+    if (g_list_first (folders))
+    {
+        GList* iter;
+        g_printerr ("midori_bookmark_folder_button_new: orphan folder(s) detected in bookmarks db\n");
+
+        for (iter = g_list_first (folders) ; iter ; iter = g_list_next (iter))
+        {
+            FolderEntry* folder = iter->data;
+            const gchar* title = folder->title;
+            gint64 id = folder->id;
+            gint64 parentid = folder->parentid;
+
+            g_printerr ("  id=%" G_GINT64_FORMAT ", parentid=%" G_GINT64_FORMAT ", title=%s\n",
+                id, parentid, title);
+        }
+
+        g_list_free_full (folders, (GDestroyNotify)midori_bookmark_folder_free_folder_entry);
+    }
+
     if (n < 2)
         gtk_widget_set_sensitive (combo, FALSE);
+
     return combo;
 }
 
@@ -887,14 +1053,8 @@
 
     if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
     {
-        gchar* selected = NULL;
         GtkTreeModel* model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
-        gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 0, &selected, 2, &id, -1);
-
-        if (g_str_equal (selected, _("Bookmarks")))
-            id = 0;
-
-        g_free (selected);
+        gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, 1, &id, -1);
     }
 
     return id;
@@ -1021,7 +1181,6 @@
     }
 
     combo_folder = midori_bookmark_folder_button_new (browser->bookmarks,
-        katze_item_get_meta_integer (bookmark, "id"),
         katze_item_get_meta_integer (bookmark, "parentid"));
     gtk_box_pack_start (GTK_BOX (vbox), combo_folder, FALSE, FALSE, 0);
 
@@ -4460,8 +4619,7 @@
     gtk_container_add (GTK_CONTAINER (content_area), hbox);
     gtk_widget_show_all (hbox);
 
-    combobox_folder = midori_bookmark_folder_button_new (browser->bookmarks,
-                                                         0, 0);
+    combobox_folder = midori_bookmark_folder_button_new (browser->bookmarks, 0);
     gtk_container_add (GTK_CONTAINER (content_area), combobox_folder);
 
     gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);