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

[André Auzi]

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.

NOTE: such orphaned folders are actually created when deleting non empty folders.

It looks like the statements "FOREIGN KEY(parentid) REFERENCES bookmarks(id) ON DELETE CASCADE" used in the bookmarks table structure does not work as expected. This should should be traced in another bug.

NOTE 1: I finally dropped the idea of displaying the folder's path in the combo box button.

First, the solution I had was only working with GTK2 and, second, I think it's more consistent this way.

[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

[lp:~aauzi/midori/fix-1177553-3]

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

merge lp:midori

6246. By André Auzi on 2013-07-18

manage a way to render combobox opened folder differently

6247. By André Auzi on 2013-07-27

implement only combo box text cell renderer by derivation

Unmerged revisions

=== added file 'katze/katze-cellrenderer2pixbufs.c'
--- katze/katze-cellrenderer2pixbufs.c	1970-01-01 00:00:00 +0000
+++ katze/katze-cellrenderer2pixbufs.c	2013-07-18 19:43:28 +0000
@@ -0,0 +1,359 @@
+/*
+ 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-cellrenderer2pixbufs.h"
+
+#include "marshal.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_2pixbufs_finalize (GObject* object);
+static void
+katze_cell_renderer_2pixbufs_get_property (GObject*    object,
+    guint       param_id,
+    GValue*     value,
+    GParamSpec* pspec);
+static void
+katze_cell_renderer_2pixbufs_set_property (GObject*      object,
+    guint         param_id,
+    const GValue* value,
+    GParamSpec*   pspec);
+static void
+katze_cell_renderer_2pixbufs_get_size (GtkCellRenderer* cell,
+    GtkWidget*       widget,
+    GdkRectangle*    cell_area,
+    gint*            x_offset,
+    gint*            y_offset,
+    gint*            width,
+    gint*            height);
+static void
+#if GTK_CHECK_VERSION(3,0,0)
+katze_cell_renderer_2pixbufs_render (GtkCellRenderer      *cell,
+    cairo_t*             cr,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GtkCellRendererState  flags);
+#else
+katze_cell_renderer_2pixbufs_render (GtkCellRenderer      *cell,
+    GdkDrawable          *window,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GdkRectangle         *expose_area,
+    GtkCellRendererState  flags);
+#endif
+
+enum {
+  PROP_0,
+  PROP_PIXBUF_EXPANDER_OPEN,
+  PROP_PIXBUF_EXPANDER_CLOSED,
+  PROP_FOLLOW_STATE,
+};
+
+#define KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), KATZE_TYPE_CELL_RENDERER_2PIXBUFS, KatzeCellRenderer2PixbufsPrivate))
+
+typedef struct _KatzeCellRenderer2PixbufsPrivate KatzeCellRenderer2PixbufsPrivate;
+struct _KatzeCellRenderer2PixbufsPrivate
+{
+  GtkCellRendererPixbuf* cellpixbuf;
+
+  guint markup_set : 1;
+  guint alternate_markup_set : 1;
+};
+
+G_DEFINE_TYPE (KatzeCellRenderer2Pixbufs, katze_cell_renderer_2pixbufs, GTK_TYPE_CELL_RENDERER)
+
+static void
+katze_cell_renderer_2pixbufs_notify (GObject    *gobject,
+                                   GParamSpec *pspec,
+                                   KatzeCellRenderer2Pixbufs *cellpixbuf)
+{
+    if (!g_strcmp0(P_("text"), pspec->name)
+        || !g_strcmp0(P_("attributes"), pspec->name))
+        return;
+
+    g_object_notify (G_OBJECT (cellpixbuf), pspec->name);
+}
+
+static void
+katze_cell_renderer_2pixbufs_init (KatzeCellRenderer2Pixbufs *cellpixbuf)
+{
+  GValue true_value = {0};
+  KatzeCellRenderer2PixbufsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE (cellpixbuf);
+
+  priv->cellpixbuf = GTK_CELL_RENDERER_PIXBUF (gtk_cell_renderer_pixbuf_new());
+  g_object_ref (priv->cellpixbuf);
+
+  g_value_init (&true_value, G_TYPE_BOOLEAN);
+  g_value_set_boolean (&true_value, TRUE);
+  g_object_set_property (G_OBJECT (priv->cellpixbuf), "is-expander", &true_value);
+  g_value_reset (&true_value);
+
+  g_signal_connect (priv->cellpixbuf, "notify",
+      G_CALLBACK (katze_cell_renderer_2pixbufs_notify),
+      cellpixbuf);
+}
+
+static void
+katze_cell_renderer_2pixbufs_class_init (KatzeCellRenderer2PixbufsClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
+
+  object_class->finalize = katze_cell_renderer_2pixbufs_finalize;
+
+  object_class->get_property = katze_cell_renderer_2pixbufs_get_property;
+  object_class->set_property = katze_cell_renderer_2pixbufs_set_property;
+
+  cell_class->get_size = katze_cell_renderer_2pixbufs_get_size;
+  cell_class->render = katze_cell_renderer_2pixbufs_render;
+
+  g_object_class_install_property (object_class,
+				   PROP_PIXBUF_EXPANDER_OPEN,
+				   g_param_spec_object ("pixbuf-expander-open",
+							P_("Pixbuf Expander Open"),
+							P_("Pixbuf for open expander"),
+							GDK_TYPE_PIXBUF,
+							GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+				   PROP_PIXBUF_EXPANDER_CLOSED,
+				   g_param_spec_object ("pixbuf-expander-closed",
+							P_("Pixbuf Expander Closed"),
+							P_("Pixbuf for closed expander"),
+							GDK_TYPE_PIXBUF,
+							GTK_PARAM_READWRITE));
+
+  /**
+   * GtkCellRendererPixbuf:follow-state:
+   *
+   * Specifies whether the rendered pixbuf should be colorized
+   * according to the #GtkCellRendererState.
+   *
+   * Since: 2.8
+   */
+  g_object_class_install_property (object_class,
+				   PROP_FOLLOW_STATE,
+				   g_param_spec_boolean ("follow-state",
+ 							 P_("Follow State"),
+ 							 P_("Whether the rendered pixbuf should be "
+							    "colorized according to the state"),
+ 							 FALSE,
+ 							 GTK_PARAM_READWRITE));
+
+  g_type_class_add_private (object_class, sizeof (KatzeCellRenderer2PixbufsPrivate));
+}
+
+static void
+katze_cell_renderer_2pixbufs_finalize (GObject *object)
+{
+  KatzeCellRenderer2Pixbufs *cellpixbuf = KATZE_CELL_RENDERER_2PIXBUFS (object);
+  KatzeCellRenderer2PixbufsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE (object);
+
+  g_object_unref (priv->cellpixbuf);
+
+  G_OBJECT_CLASS (katze_cell_renderer_2pixbufs_parent_class)->finalize (object);
+}
+
+static const gchar* const cell_pixbuf_renderer_property_names[] =
+{
+  /* GtkCellRendererPixbuf args */
+  "pixbuf-expander-open",
+  "pixbuf-expander-closed",
+  "follow-state"
+};
+
+static void
+katze_cell_renderer_2pixbufs_get_property (GObject*    object,
+					 guint       param_id,
+					 GValue*     value,
+					 GParamSpec* pspec)
+{
+  KatzeCellRenderer2Pixbufs *cellpixbuf = KATZE_CELL_RENDERER_2PIXBUFS (object);
+  KatzeCellRenderer2PixbufsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE (object);
+
+  switch (param_id)
+    {
+    case PROP_PIXBUF_EXPANDER_OPEN:
+    case PROP_PIXBUF_EXPANDER_CLOSED:
+    case PROP_FOLLOW_STATE:
+      g_object_get_property (G_OBJECT (priv->cellpixbuf), cell_pixbuf_renderer_property_names[param_id-PROP_PIXBUF_EXPANDER_OPEN], value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
+
+
+static void
+katze_cell_renderer_2pixbufs_set_property (GObject*      object,
+					 guint         param_id,
+					 const GValue* value,
+					 GParamSpec*   pspec)
+{
+  KatzeCellRenderer2Pixbufs *cellpixbuf = KATZE_CELL_RENDERER_2PIXBUFS (object);
+  KatzeCellRenderer2PixbufsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE (object);
+
+  switch (param_id)
+    {
+    case PROP_PIXBUF_EXPANDER_OPEN:
+    case PROP_PIXBUF_EXPANDER_CLOSED:
+    case PROP_FOLLOW_STATE:
+      g_object_set_property (G_OBJECT (priv->cellpixbuf), cell_pixbuf_renderer_property_names[param_id-PROP_PIXBUF_EXPANDER_OPEN], value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
+
+/**
+ * katze_cell_renderer_2pixbufs_new:
+ *
+ * Creates a new #KatzeCellRenderer2Pixbufs. 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_2pixbufs_new (void)
+{
+  return g_object_new (KATZE_TYPE_CELL_RENDERER_2PIXBUFS, NULL);
+}
+
+static GtkCellRendererState
+set_pixbuf(KatzeCellRenderer2Pixbufs*        cellpixbuf,
+    GtkWidget*                      widget,
+    KatzeCellRenderer2PixbufsPrivate* priv,
+    GtkCellRendererState flags)
+{
+  GtkWidget* pwidget = gtk_widget_get_parent (widget);
+  gboolean alternate = FALSE;
+  GValue false_value = {0};
+  GValue true_value = {0};
+  g_value_init (&false_value, G_TYPE_BOOLEAN);
+  g_value_init (&true_value, G_TYPE_BOOLEAN);
+  g_value_set_boolean (&false_value, FALSE);
+  g_value_set_boolean (&true_value, TRUE);
+
+  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)))
+      {
+          alternate = TRUE;
+      }
+    }
+
+  g_object_set_property (G_OBJECT (priv->cellpixbuf), "is-expander", &true_value);
+  if (alternate)
+    {
+        flags |= (1<<6) /* GTK_CELL_RENDERER_EXPANDED */ ;
+        g_object_set_property (G_OBJECT (priv->cellpixbuf), "is-expanded", &true_value);
+    }
+  else
+    {
+        flags |= (1<<5) /* GTK_CELL_RENDERER_EXPANDABLE*/ ;
+        g_object_set_property (G_OBJECT (priv->cellpixbuf), "is-expanded", &false_value);
+    }
+  return flags;
+}
+
+static void
+katze_cell_renderer_2pixbufs_get_size (GtkCellRenderer *cell,
+				 GtkWidget       *widget,
+				 GdkRectangle    *cell_area,
+				 gint            *x_offset,
+				 gint            *y_offset,
+				 gint            *width,
+				 gint            *height)
+{
+  KatzeCellRenderer2Pixbufs *cellpixbuf = (KatzeCellRenderer2Pixbufs *) cell;
+  KatzeCellRenderer2PixbufsPrivate *priv;
+  priv = KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE (cell);
+
+  gtk_cell_renderer_get_size (GTK_CELL_RENDERER (priv->cellpixbuf),
+			      widget, cell_area,
+			      x_offset, y_offset, width, height);
+}
+
+static void
+#if GTK_CHECK_VERSION(3,0,0)
+katze_cell_renderer_2pixbufs_render (GtkCellRenderer      *cell,
+			       cairo_t*             cr,
+			       GtkWidget            *widget,
+			       GdkRectangle         *background_area,
+			       GdkRectangle         *cell_area,
+			       GtkCellRendererState  flags)
+#else
+katze_cell_renderer_2pixbufs_render (GtkCellRenderer      *cell,
+			       GdkDrawable          *window,
+			       GtkWidget            *widget,
+			       GdkRectangle         *background_area,
+			       GdkRectangle         *cell_area,
+			       GdkRectangle         *expose_area,
+			       GtkCellRendererState  flags)
+#endif
+{
+  KatzeCellRenderer2Pixbufs *cellpixbuf = (KatzeCellRenderer2Pixbufs *) cell;
+  KatzeCellRenderer2PixbufsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2PIXBUFS_GET_PRIVATE (cell);
+
+
+#if GTK_CHECK_VERSION(3,0,0)
+  gtk_cell_renderer_render (GTK_CELL_RENDERER (priv->cellpixbuf),
+      cr,
+      widget,
+      background_area,
+      cell_area,
+      set_pixbuf (cellpixbuf, widget, priv, flags));
+#else
+  gtk_cell_renderer_render (GTK_CELL_RENDERER (priv->cellpixbuf),
+      window,
+      widget,
+      background_area,
+      cell_area,
+      expose_area,
+      set_pixbuf (cellpixbuf, widget, priv, flags));
+#endif
+}
 
=== added file 'katze/katze-cellrenderer2pixbufs.h'
--- katze/katze-cellrenderer2pixbufs.h	1970-01-01 00:00:00 +0000
+++ katze/katze-cellrenderer2pixbufs.h	2013-07-18 19:43:28 +0000
@@ -0,0 +1,59 @@
+/*
+ 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_2PIXBUFS_H__
+#define __KATZE_CELL_RENDERER_2PIXBUFS_H__
+
+
+#include <gtk/gtk.h>
+
+#ifndef GSEAL
+#define GSEAL(String) String
+#endif
+
+
+G_BEGIN_DECLS
+
+
+#define KATZE_TYPE_CELL_RENDERER_2PIXBUFS			(katze_cell_renderer_2pixbufs_get_type ())
+#define KATZE_CELL_RENDERER_2PIXBUFS(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), KATZE_TYPE_CELL_RENDERER_2PIXBUFS, KatzeCellRenderer2Pixbufs))
+#define KATZE_CELL_RENDERER_2PIXBUFS_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), KATZE_TYPE_CELL_RENDERER_2PIXBUFS, KatzeCellRenderer2PixbufsClass))
+#define KATZE_IS_CELL_RENDERER_2PIXBUFS(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), KATZE_TYPE_CELL_RENDERER_2PIXBUFS))
+#define KATZE_IS_CELL_RENDERER_2PIXBUFS_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), KATZE_TYPE_CELL_RENDERER_2PIXBUFS))
+#define KATZE_CELL_RENDERER_2PIXBUFS_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), KATZE_TYPE_CELL_RENDERER_2PIXBUFS, GtkCellRenderer2PixbufsClass))
+
+typedef struct _KatzeCellRenderer2Pixbufs KatzeCellRenderer2Pixbufs;
+typedef struct _KatzeCellRenderer2PixbufsClass KatzeCellRenderer2PixbufsClass;
+
+struct _KatzeCellRenderer2Pixbufs
+{
+  GtkCellRenderer parent;
+};
+
+struct _KatzeCellRenderer2PixbufsClass
+{
+  GtkCellRendererClass 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_2pixbufs_get_type (void) G_GNUC_CONST;
+GtkCellRenderer *katze_cell_renderer_2pixbufs_new      (void);
+
+
+G_END_DECLS
+
+
+#endif /* __KATZE_CELL_RENDERER_2PIXBUFS_H__ */
 
=== added file 'katze/katze-cellrenderer2texts.c'
--- katze/katze-cellrenderer2texts.c	1970-01-01 00:00:00 +0000
+++ katze/katze-cellrenderer2texts.c	2013-07-18 19:43:28 +0000
@@ -0,0 +1,1136 @@
+/*
+ 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-cellrenderer2texts.h"
+
+#include "marshal.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_2texts_finalize (GObject* object);
+
+static void
+katze_cell_renderer_2texts_get_property (GObject*    object,
+    guint       param_id,
+    GValue*     value,
+    GParamSpec* pspec);
+static void
+katze_cell_renderer_2texts_set_property (GObject*      object,
+    guint         param_id,
+    const GValue* value,
+    GParamSpec*   pspec);
+static void
+katze_cell_renderer_2texts_get_size (GtkCellRenderer* cell,
+    GtkWidget*       widget,
+    GdkRectangle*    cell_area,
+    gint*            x_offset,
+    gint*            y_offset,
+    gint*            width,
+    gint*            height);
+static void
+#if GTK_CHECK_VERSION(3,0,0)
+katze_cell_renderer_2texts_render (GtkCellRenderer      *cell,
+    cairo_t*             cr,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GtkCellRendererState  flags);
+#else
+katze_cell_renderer_2texts_render (GtkCellRenderer      *cell,
+    GdkDrawable          *window,
+    GtkWidget            *widget,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GdkRectangle         *expose_area,
+    GtkCellRendererState  flags);
+#endif
+
+static GtkCellEditable *
+katze_cell_renderer_2texts_start_editing (GtkCellRenderer      *cell,
+    GdkEvent             *event,
+    GtkWidget            *widget,
+    const gchar          *path,
+    GdkRectangle         *background_area,
+    GdkRectangle         *cell_area,
+    GtkCellRendererState  flags);
+
+enum {
+  EDITED,
+  LAST_SIGNAL
+};
+
+enum {
+  PROP_0,
+
+  PROP_TEXT,
+  PROP_MARKUP,
+  PROP_ATTRIBUTES,
+  PROP_ALTERNATE_TEXT,
+  PROP_ALTERNATE_MARKUP,
+  PROP_ALTERNATE_ATTRIBUTES,
+
+  /* GtkCellRendererText args */
+  PROP_SINGLE_PARAGRAPH_MODE,
+  PROP_WIDTH_CHARS,
+  PROP_WRAP_WIDTH,
+  PROP_ALIGN,
+
+  /* Style args */
+  PROP_BACKGROUND,
+  PROP_FOREGROUND,
+  PROP_BACKGROUND_GDK,
+  PROP_FOREGROUND_GDK,
+  PROP_FONT,
+  PROP_FONT_DESC,
+  PROP_FAMILY,
+  PROP_STYLE,
+  PROP_VARIANT,
+  PROP_WEIGHT,
+  PROP_STRETCH,
+  PROP_SIZE,
+  PROP_SIZE_POINTS,
+  PROP_SCALE,
+  PROP_EDITABLE,
+  PROP_STRIKETHROUGH,
+  PROP_UNDERLINE,
+  PROP_RISE,
+  PROP_LANGUAGE,
+  PROP_ELLIPSIZE,
+  PROP_WRAP_MODE,
+
+  /* Whether-a-style-arg-is-set args */
+  PROP_BACKGROUND_SET,
+  PROP_FOREGROUND_SET,
+  PROP_FAMILY_SET,
+  PROP_STYLE_SET,
+  PROP_VARIANT_SET,
+  PROP_WEIGHT_SET,
+  PROP_STRETCH_SET,
+  PROP_SIZE_SET,
+  PROP_SCALE_SET,
+  PROP_EDITABLE_SET,
+  PROP_STRIKETHROUGH_SET,
+  PROP_UNDERLINE_SET,
+  PROP_RISE_SET,
+  PROP_LANGUAGE_SET,
+  PROP_ELLIPSIZE_SET,
+  PROP_ALIGN_SET
+};
+
+static guint _2texts_cell_renderer_signals [LAST_SIGNAL];
+
+#define KATZE_CELL_RENDERER_2TEXTS_PATH "gtk-cell-renderer-text-path"
+
+#define KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), KATZE_TYPE_CELL_RENDERER_2TEXTS, KatzeCellRenderer2textsPrivate))
+
+typedef struct _KatzeCellRenderer2textsPrivate KatzeCellRenderer2textsPrivate;
+struct _KatzeCellRenderer2textsPrivate
+{
+  GtkCellRendererText* celltext;
+
+  guint markup_set : 1;
+  guint alternate_markup_set : 1;
+};
+
+G_DEFINE_TYPE (KatzeCellRenderer2texts, katze_cell_renderer_2texts, GTK_TYPE_CELL_RENDERER)
+
+static void
+katze_cell_renderer_2texts_notify (GObject    *gobject,
+                                   GParamSpec *pspec,
+                                   KatzeCellRenderer2texts *celltext)
+{
+    if (!g_strcmp0(P_("text"), pspec->name)
+        || !g_strcmp0(P_("attributes"), pspec->name))
+        return;
+
+    g_object_notify (G_OBJECT (celltext), pspec->name);
+}
+
+static void
+katze_cell_renderer_2texts_init (KatzeCellRenderer2texts *celltext)
+{
+  KatzeCellRenderer2textsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (celltext);
+
+  priv->celltext = GTK_CELL_RENDERER_TEXT (gtk_cell_renderer_text_new());
+  g_object_ref (priv->celltext);
+
+  priv->markup_set = FALSE;
+  priv->alternate_markup_set = FALSE;
+
+  g_signal_connect (priv->celltext, "notify",
+      G_CALLBACK (katze_cell_renderer_2texts_notify),
+      celltext);
+}
+
+static void
+katze_cell_renderer_2texts_class_init (KatzeCellRenderer2textsClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
+
+  object_class->finalize = katze_cell_renderer_2texts_finalize;
+
+  object_class->get_property = katze_cell_renderer_2texts_get_property;
+  object_class->set_property = katze_cell_renderer_2texts_set_property;
+
+  cell_class->get_size = katze_cell_renderer_2texts_get_size;
+  cell_class->render = katze_cell_renderer_2texts_render;
+  cell_class->start_editing = katze_cell_renderer_2texts_start_editing;
+
+  g_object_class_install_property (object_class,
+                                   PROP_TEXT,
+                                   g_param_spec_string ("text",
+                                                        P_("Text"),
+                                                        P_("Text to render"),
+                                                        NULL,
+                                                        GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_ALTERNATE_TEXT,
+                                   g_param_spec_string ("alternate-text",
+                                                        P_("Alternate text"),
+                                                        P_("Text to render if 2texts is opened"),
+                                                        NULL,
+                                                        GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_MARKUP,
+                                   g_param_spec_string ("markup",
+                                                        P_("Markup"),
+                                                        P_("Marked up text to render"),
+                                                        NULL,
+                                                        GTK_PARAM_WRITABLE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_ALTERNATE_MARKUP,
+                                   g_param_spec_string ("alternate-markup",
+                                                        P_("Markup"),
+                                                        P_("Marked up text to render if 2texts is opened"),
+                                                        NULL,
+                                                        GTK_PARAM_WRITABLE));
+
+  g_object_class_install_property (object_class,
+				   PROP_ATTRIBUTES,
+				   g_param_spec_boxed ("attributes",
+						       P_("Attributes"),
+						       P_("A list of style attributes to apply to the text of the renderer"),
+						       PANGO_TYPE_ATTR_LIST,
+						       GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+				   PROP_ALTERNATE_ATTRIBUTES,
+				   g_param_spec_boxed ("alternate-attributes",
+						       P_("Attributes"),
+						       P_("A list of style attributes to apply to the text of the renderer"),
+						       PANGO_TYPE_ATTR_LIST,
+						       GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_SINGLE_PARAGRAPH_MODE,
+                                   g_param_spec_boolean ("single-paragraph-mode",
+                                                         P_("Single Paragraph Mode"),
+                                                         P_("Whether or not to keep all text in a single paragraph"),
+                                                         FALSE,
+                                                         GTK_PARAM_READWRITE));
+
+
+  g_object_class_install_property (object_class,
+                                   PROP_BACKGROUND,
+                                   g_param_spec_string ("background",
+                                                        P_("Background color name"),
+                                                        P_("Background color as a string"),
+                                                        NULL,
+                                                        GTK_PARAM_WRITABLE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_BACKGROUND_GDK,
+                                   g_param_spec_boxed ("background-gdk",
+                                                       P_("Background color"),
+                                                       P_("Background color as a GdkColor"),
+                                                       GDK_TYPE_COLOR,
+                                                       GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_FOREGROUND,
+                                   g_param_spec_string ("foreground",
+                                                        P_("Foreground color name"),
+                                                        P_("Foreground color as a string"),
+                                                        NULL,
+                                                        GTK_PARAM_WRITABLE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_FOREGROUND_GDK,
+                                   g_param_spec_boxed ("foreground-gdk",
+                                                       P_("Foreground color"),
+                                                       P_("Foreground color as a GdkColor"),
+                                                       GDK_TYPE_COLOR,
+                                                       GTK_PARAM_READWRITE));
+
+
+  g_object_class_install_property (object_class,
+                                   PROP_EDITABLE,
+                                   g_param_spec_boolean ("editable",
+                                                         P_("Editable"),
+                                                         P_("Whether the text can be modified by the user"),
+                                                         FALSE,
+                                                         GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_FONT,
+                                   g_param_spec_string ("font",
+                                                        P_("Font"),
+                                                        P_("Font description as a string, e.g. \"Sans Italic 12\""),
+                                                        NULL,
+                                                        GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_FONT_DESC,
+                                   g_param_spec_boxed ("font-desc",
+                                                       P_("Font"),
+                                                       P_("Font description as a PangoFontDescription struct"),
+                                                       PANGO_TYPE_FONT_DESCRIPTION,
+                                                       GTK_PARAM_READWRITE));
+
+
+  g_object_class_install_property (object_class,
+                                   PROP_FAMILY,
+                                   g_param_spec_string ("family",
+                                                        P_("Font family"),
+                                                        P_("Name of the font family, e.g. Sans, Helvetica, Times, Monospace"),
+                                                        NULL,
+                                                        GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_STYLE,
+                                   g_param_spec_enum ("style",
+                                                      P_("Font style"),
+                                                      P_("Font style"),
+                                                      PANGO_TYPE_STYLE,
+                                                      PANGO_STYLE_NORMAL,
+                                                      GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_VARIANT,
+                                   g_param_spec_enum ("variant",
+                                                     P_("Font variant"),
+                                                     P_("Font variant"),
+                                                      PANGO_TYPE_VARIANT,
+                                                      PANGO_VARIANT_NORMAL,
+                                                      GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_WEIGHT,
+                                   g_param_spec_int ("weight",
+                                                     P_("Font weight"),
+                                                     P_("Font weight"),
+                                                     0,
+                                                     G_MAXINT,
+                                                     PANGO_WEIGHT_NORMAL,
+                                                     GTK_PARAM_READWRITE));
+
+   g_object_class_install_property (object_class,
+                                   PROP_STRETCH,
+                                   g_param_spec_enum ("stretch",
+                                                      P_("Font stretch"),
+                                                      P_("Font stretch"),
+                                                      PANGO_TYPE_STRETCH,
+                                                      PANGO_STRETCH_NORMAL,
+                                                      GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_SIZE,
+                                   g_param_spec_int ("size",
+                                                     P_("Font size"),
+                                                     P_("Font size"),
+                                                     0,
+                                                     G_MAXINT,
+                                                     0,
+                                                     GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_SIZE_POINTS,
+                                   g_param_spec_double ("size-points",
+                                                        P_("Font points"),
+                                                        P_("Font size in points"),
+                                                        0.0,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_SCALE,
+                                   g_param_spec_double ("scale",
+                                                        P_("Font scale"),
+                                                        P_("Font scaling factor"),
+                                                        0.0,
+                                                        G_MAXDOUBLE,
+                                                        1.0,
+                                                        GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_RISE,
+                                   g_param_spec_int ("rise",
+                                                     P_("Rise"),
+                                                     P_("Offset of text above the baseline "
+							"(below the baseline if rise is negative)"),
+                                                     -G_MAXINT,
+                                                     G_MAXINT,
+                                                     0,
+                                                     GTK_PARAM_READWRITE));
+
+
+  g_object_class_install_property (object_class,
+                                   PROP_STRIKETHROUGH,
+                                   g_param_spec_boolean ("strikethrough",
+                                                         P_("Strikethrough"),
+                                                         P_("Whether to strike through the text"),
+                                                         FALSE,
+                                                         GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_UNDERLINE,
+                                   g_param_spec_enum ("underline",
+                                                      P_("Underline"),
+                                                      P_("Style of underline for this text"),
+                                                      PANGO_TYPE_UNDERLINE,
+                                                      PANGO_UNDERLINE_NONE,
+                                                      GTK_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_LANGUAGE,
+                                   g_param_spec_string ("language",
+                                                        P_("Language"),
+                                                        P_("The language this text is in, as an ISO code. "
+							   "Pango can use this as a hint when rendering the text. "
+							   "If you don't understand this parameter, you probably don't need it"),
+                                                        NULL,
+                                                        GTK_PARAM_READWRITE));
+
+
+  /**
+   * KatzeCellRenderer2texts:ellipsize:
+   *
+   * Specifies the preferred place to ellipsize the string, if the cell renderer
+   * does not have enough room to display the entire string. Setting it to
+   * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
+   * for another way of making the text fit into a given width.
+   *
+   * Since: 2.6
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_ELLIPSIZE,
+                                   g_param_spec_enum ("ellipsize",
+						      P_("Ellipsize"),
+						      P_("The preferred place to ellipsize the string, "
+							 "if the cell renderer does not have enough room "
+							 "to display the entire string"),
+						      PANGO_TYPE_ELLIPSIZE_MODE,
+						      PANGO_ELLIPSIZE_NONE,
+						      GTK_PARAM_READWRITE));
+
+  /**
+   * KatzeCellRenderer2texts:width-chars:
+   *
+   * The desired width of the cell, in characters. If this property is set to
+   * -1, the width will be calculated automatically, otherwise the cell will
+   * request either 3 characters or the property value, whichever is greater.
+   *
+   * Since: 2.6
+   **/
+  g_object_class_install_property (object_class,
+                                   PROP_WIDTH_CHARS,
+                                   g_param_spec_int ("width-chars",
+                                                     P_("Width In Characters"),
+                                                     P_("The desired width of the label, in characters"),
+                                                     -1,
+                                                     G_MAXINT,
+                                                     -1,
+                                                     GTK_PARAM_READWRITE));
+
+  /**
+   * KatzeCellRenderer2texts:wrap-mode:
+   *
+   * Specifies how to break the string into multiple lines, if the cell
+   * renderer does not have enough room to display the entire string.
+   * This property has no effect unless the wrap-width property is set.
+   *
+   * Since: 2.8
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_WRAP_MODE,
+                                   g_param_spec_enum ("wrap-mode",
+						      P_("Wrap mode"),
+						      P_("How to break the string into multiple lines, "
+							 "if the cell renderer does not have enough room "
+							 "to display the entire string"),
+						      PANGO_TYPE_WRAP_MODE,
+						      PANGO_WRAP_CHAR,
+						      GTK_PARAM_READWRITE));
+
+  /**
+   * KatzeCellRenderer2texts:wrap-width:
+   *
+   * Specifies the width at which the text is wrapped. The wrap-mode property can
+   * be used to influence at what character positions the line breaks can be placed.
+   * Setting wrap-width to -1 turns wrapping off.
+   *
+   * Since: 2.8
+   */
+  g_object_class_install_property (object_class,
+				   PROP_WRAP_WIDTH,
+				   g_param_spec_int ("wrap-width",
+						     P_("Wrap width"),
+						     P_("The width at which the text is wrapped"),
+						     -1,
+						     G_MAXINT,
+						     -1,
+						     GTK_PARAM_READWRITE));
+
+  /**
+   * KatzeCellRenderer2texts:alignment:
+   *
+   * Specifies how to align the lines of text with respect to each other.
+   *
+   * Note that this property describes how to align the lines of text in
+   * case there are several of them. The "xalign" property of #GtkCellRenderer,
+   * on the other hand, sets the horizontal alignment of the whole text.
+   *
+   * Since: 2.10
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_ALIGN,
+                                   g_param_spec_enum ("alignment",
+						      P_("Alignment"),
+						      P_("How to align the lines"),
+						      PANGO_TYPE_ALIGNMENT,
+						      PANGO_ALIGN_LEFT,
+						      GTK_PARAM_READWRITE));
+
+  /* Style props are set or not */
+
+#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
+
+  ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
+                P_("Background set"),
+                P_("Whether this tag affects the background color"));
+
+  ADD_SET_PROP ("foreground-set", PROP_FOREGROUND_SET,
+                P_("Foreground set"),
+                P_("Whether this tag affects the foreground color"));
+
+  ADD_SET_PROP ("editable-set", PROP_EDITABLE_SET,
+                P_("Editability set"),
+                P_("Whether this tag affects text editability"));
+
+  ADD_SET_PROP ("family-set", PROP_FAMILY_SET,
+                P_("Font family set"),
+                P_("Whether this tag affects the font family"));
+
+  ADD_SET_PROP ("style-set", PROP_STYLE_SET,
+                P_("Font style set"),
+                P_("Whether this tag affects the font style"));
+
+  ADD_SET_PROP ("variant-set", PROP_VARIANT_SET,
+                P_("Font variant set"),
+                P_("Whether this tag affects the font variant"));
+
+  ADD_SET_PROP ("weight-set", PROP_WEIGHT_SET,
+                P_("Font weight set"),
+                P_("Whether this tag affects the font weight"));
+
+  ADD_SET_PROP ("stretch-set", PROP_STRETCH_SET,
+                P_("Font stretch set"),
+                P_("Whether this tag affects the font stretch"));
+
+  ADD_SET_PROP ("size-set", PROP_SIZE_SET,
+                P_("Font size set"),
+                P_("Whether this tag affects the font size"));
+
+  ADD_SET_PROP ("scale-set", PROP_SCALE_SET,
+                P_("Font scale set"),
+                P_("Whether this tag scales the font size by a factor"));
+
+  ADD_SET_PROP ("rise-set", PROP_RISE_SET,
+                P_("Rise set"),
+                P_("Whether this tag affects the rise"));
+
+  ADD_SET_PROP ("strikethrough-set", PROP_STRIKETHROUGH_SET,
+                P_("Strikethrough set"),
+                P_("Whether this tag affects strikethrough"));
+
+  ADD_SET_PROP ("underline-set", PROP_UNDERLINE_SET,
+                P_("Underline set"),
+                P_("Whether this tag affects underlining"));
+
+  ADD_SET_PROP ("language-set", PROP_LANGUAGE_SET,
+                P_("Language set"),
+                P_("Whether this tag affects the language the text is rendered as"));
+
+  ADD_SET_PROP ("ellipsize-set", PROP_ELLIPSIZE_SET,
+                P_("Ellipsize set"),
+                P_("Whether this tag affects the ellipsize mode"));
+
+  ADD_SET_PROP ("align-set", PROP_ALIGN_SET,
+                P_("Align set"),
+                P_("Whether this tag affects the alignment mode"));
+
+  /**
+   * KatzeCellRenderer2texts::edited
+   * @renderer: the object which received the signal
+   * @path: the path identifying the edited cell
+   * @new_text: the new text
+   *
+   * This signal is emitted after @renderer has been edited.
+   *
+   * It is the responsibility of the application to update the model
+   * and store @new_text at the position indicated by @path.
+   */
+  _2texts_cell_renderer_signals [EDITED] =
+    g_signal_new (I_("edited"),
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (KatzeCellRenderer2textsClass, edited),
+		  NULL, NULL,
+		  midori_cclosure_marshal_VOID__STRING_STRING,
+		  G_TYPE_NONE, 2,
+		  G_TYPE_STRING,
+		  G_TYPE_STRING);
+
+  g_type_class_add_private (object_class, sizeof (KatzeCellRenderer2textsPrivate));
+}
+
+static void
+katze_cell_renderer_2texts_finalize (GObject *object)
+{
+  KatzeCellRenderer2texts *celltext = KATZE_CELL_RENDERER_2TEXTS (object);
+  KatzeCellRenderer2textsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (object);
+
+  g_free (celltext->text);
+  if (celltext->extra_attrs)
+    pango_attr_list_unref (celltext->extra_attrs);
+
+  g_free (celltext->alternate_text);
+  if (celltext->alternate_extra_attrs)
+    pango_attr_list_unref (celltext->alternate_extra_attrs);
+
+  g_object_unref (priv->celltext);
+
+  G_OBJECT_CLASS (katze_cell_renderer_2texts_parent_class)->finalize (object);
+}
+
+static const gchar* const cell_text_renderer_property_names[] =
+{
+  /* GtkCellRendererText args */
+  "single-paragraph-mode",
+  "width-chars",
+  "wrap-width",
+  "align",
+
+  /* Style args */
+  "background",
+  "foreground",
+  "background-gdk",
+  "foreground-gdk",
+  "font",
+  "font-desc",
+  "family",
+  "style",
+  "variant",
+  "weight",
+  "stretch",
+  "size",
+  "size-points",
+  "scale",
+  "editable",
+  "strikethrough",
+  "underline",
+  "rise",
+  "language",
+  "ellipsize",
+  "wrap-mode",
+
+  /* Whether-a-style-arg-is-set args */
+  "background-set",
+  "foreground-set",
+  "family-set",
+  "style-set",
+  "variant-set",
+  "weight-set",
+  "stretch-set",
+  "size-set",
+  "scale-set",
+  "editable-set",
+  "strikethrough-set",
+  "underline-set",
+  "rise-set",
+  "language-set",
+  "ellipsize-set",
+  "align-set"
+};
+
+static void
+katze_cell_renderer_2texts_get_property (GObject*    object,
+					 guint       param_id,
+					 GValue*     value,
+					 GParamSpec* pspec)
+{
+  KatzeCellRenderer2texts *celltext = KATZE_CELL_RENDERER_2TEXTS (object);
+  KatzeCellRenderer2textsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (object);
+
+  switch (param_id)
+    {
+    case PROP_TEXT:
+      g_value_set_string (value, celltext->text);
+      break;
+
+    case PROP_ATTRIBUTES:
+      g_value_set_boxed (value, celltext->extra_attrs);
+      break;
+
+    case PROP_ALTERNATE_TEXT:
+      g_value_set_string (value, celltext->alternate_text);
+      break;
+
+    case PROP_ALTERNATE_ATTRIBUTES:
+      g_value_set_boxed (value, celltext->alternate_extra_attrs);
+      break;
+
+    case PROP_SINGLE_PARAGRAPH_MODE:
+    case PROP_BACKGROUND_GDK:
+    case PROP_FOREGROUND_GDK:
+    case PROP_FONT:
+    case PROP_FONT_DESC:
+    case PROP_FAMILY:
+    case PROP_STYLE:
+    case PROP_VARIANT:
+    case PROP_WEIGHT:
+    case PROP_STRETCH:
+    case PROP_SIZE:
+    case PROP_SIZE_POINTS:
+    case PROP_SCALE:
+    case PROP_EDITABLE:
+    case PROP_STRIKETHROUGH:
+    case PROP_UNDERLINE:
+    case PROP_RISE:
+    case PROP_LANGUAGE:
+    case PROP_ELLIPSIZE:
+    case PROP_WRAP_MODE:
+    case PROP_WRAP_WIDTH:
+    case PROP_ALIGN:
+    case PROP_BACKGROUND_SET:
+    case PROP_FOREGROUND_SET:
+    case PROP_FAMILY_SET:
+    case PROP_STYLE_SET:
+    case PROP_VARIANT_SET:
+    case PROP_WEIGHT_SET:
+    case PROP_STRETCH_SET:
+    case PROP_SIZE_SET:
+    case PROP_SCALE_SET:
+    case PROP_EDITABLE_SET:
+    case PROP_STRIKETHROUGH_SET:
+    case PROP_UNDERLINE_SET:
+    case PROP_RISE_SET:
+    case PROP_LANGUAGE_SET:
+    case PROP_ELLIPSIZE_SET:
+    case PROP_ALIGN_SET:
+    case PROP_WIDTH_CHARS:
+    case PROP_BACKGROUND:
+    case PROP_FOREGROUND:
+      g_object_get_property (G_OBJECT (priv->celltext), cell_text_renderer_property_names[param_id-PROP_SINGLE_PARAGRAPH_MODE], value);
+      break;
+    case PROP_MARKUP:
+    case PROP_ALTERNATE_MARKUP:
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
+
+
+static void
+katze_cell_renderer_2texts_set_property (GObject*      object,
+					 guint         param_id,
+					 const GValue* value,
+					 GParamSpec*   pspec)
+{
+  KatzeCellRenderer2texts *celltext = KATZE_CELL_RENDERER_2TEXTS (object);
+  KatzeCellRenderer2textsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (object);
+
+  switch (param_id)
+    {
+    case PROP_TEXT:
+      g_free (celltext->text);
+
+      if (priv->markup_set)
+        {
+          if (celltext->extra_attrs)
+            pango_attr_list_unref (celltext->extra_attrs);
+          celltext->extra_attrs = NULL;
+          priv->markup_set = FALSE;
+        }
+
+      celltext->text = g_value_dup_string (value);
+      g_object_notify (object, "text");
+      break;
+   case PROP_ATTRIBUTES:
+      if (celltext->extra_attrs)
+	pango_attr_list_unref (celltext->extra_attrs);
+
+      celltext->extra_attrs = g_value_get_boxed (value);
+      if (celltext->extra_attrs)
+        pango_attr_list_ref (celltext->extra_attrs);
+      break;
+    case 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 (celltext->text);
+
+	if (celltext->extra_attrs)
+	  pango_attr_list_unref (celltext->extra_attrs);
+
+	celltext->text = text;
+	celltext->extra_attrs = attrs;
+        priv->markup_set = TRUE;
+      }
+      break;
+
+    case PROP_ALTERNATE_TEXT:
+      g_free (celltext->alternate_text);
+
+      if (priv->alternate_markup_set)
+        {
+          if (celltext->alternate_extra_attrs)
+            pango_attr_list_unref (celltext->alternate_extra_attrs);
+          celltext->alternate_extra_attrs = NULL;
+          priv->alternate_markup_set = FALSE;
+        }
+
+      celltext->alternate_text = g_value_dup_string (value);
+      g_object_notify (object, "alternate-text");
+      break;
+   case PROP_ALTERNATE_ATTRIBUTES:
+      if (celltext->alternate_extra_attrs)
+	pango_attr_list_unref (celltext->alternate_extra_attrs);
+
+      celltext->alternate_extra_attrs = g_value_get_boxed (value);
+      if (celltext->alternate_extra_attrs)
+        pango_attr_list_ref (celltext->alternate_extra_attrs);
+      break;
+    case PROP_ALTERNATE_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 (celltext->alternate_text);
+
+	if (celltext->alternate_extra_attrs)
+	  pango_attr_list_unref (celltext->alternate_extra_attrs);
+
+	celltext->alternate_text = text;
+	celltext->alternate_extra_attrs = attrs;
+        priv->alternate_markup_set = TRUE;
+      }
+      break;
+
+    case PROP_SINGLE_PARAGRAPH_MODE:
+    case PROP_BACKGROUND:
+    case PROP_FOREGROUND:
+    case PROP_BACKGROUND_GDK:
+    case PROP_FOREGROUND_GDK:
+    case PROP_FONT:
+    case PROP_FONT_DESC:
+    case PROP_FAMILY:
+    case PROP_STYLE:
+    case PROP_VARIANT:
+    case PROP_WEIGHT:
+    case PROP_STRETCH:
+    case PROP_SIZE:
+    case PROP_SIZE_POINTS:
+    case PROP_SCALE:
+    case PROP_EDITABLE:
+    case PROP_STRIKETHROUGH:
+    case PROP_UNDERLINE:
+    case PROP_RISE:
+    case PROP_LANGUAGE:
+    case PROP_ELLIPSIZE:
+    case PROP_WRAP_MODE:
+    case PROP_WRAP_WIDTH:
+    case PROP_WIDTH_CHARS:
+    case PROP_ALIGN:
+    case PROP_BACKGROUND_SET:
+    case PROP_FOREGROUND_SET:
+    case PROP_FAMILY_SET:
+    case PROP_STYLE_SET:
+    case PROP_VARIANT_SET:
+    case PROP_WEIGHT_SET:
+    case PROP_STRETCH_SET:
+    case PROP_SIZE_SET:
+    case PROP_SCALE_SET:
+    case PROP_EDITABLE_SET:
+    case PROP_STRIKETHROUGH_SET:
+    case PROP_UNDERLINE_SET:
+    case PROP_RISE_SET:
+    case PROP_LANGUAGE_SET:
+    case PROP_ELLIPSIZE_SET:
+    case PROP_ALIGN_SET:
+      g_object_set_property (G_OBJECT (priv->celltext), cell_text_renderer_property_names[param_id-PROP_SINGLE_PARAGRAPH_MODE], value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
+
+/**
+ * katze_cell_renderer_2texts_new:
+ *
+ * Creates a new #KatzeCellRenderer2texts. 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_2texts_new (void)
+{
+  return g_object_new (KATZE_TYPE_CELL_RENDERER_2TEXTS, NULL);
+}
+
+static void
+set_text(KatzeCellRenderer2texts*        celltext,
+	 GtkWidget*                      widget,
+	 KatzeCellRenderer2textsPrivate* priv)
+{
+  GValue text_value = {0};
+  GValue attrs_value = {0};
+  GtkWidget* pwidget = gtk_widget_get_parent (widget);
+  gboolean alternate = FALSE;
+
+  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)))
+	{
+	  alternate = TRUE;
+	}
+    }
+
+  g_value_init (&text_value, G_TYPE_STRING);
+  g_value_init (&attrs_value, PANGO_TYPE_ATTR_LIST);
+
+  if (alternate)
+    {
+      g_value_set_static_string (&text_value, celltext->alternate_text);
+      g_value_set_boxed (&attrs_value, celltext->alternate_extra_attrs);
+    }
+  else
+    {
+      g_value_set_static_string (&text_value, celltext->text);
+      g_value_set_boxed (&attrs_value, celltext->extra_attrs);
+    }
+
+  g_object_set_property (G_OBJECT (priv->celltext),
+			 "text", &text_value);
+  g_object_set_property (G_OBJECT (priv->celltext),
+			 "attributes", &attrs_value);
+
+}
+
+static void
+katze_cell_renderer_2texts_get_size (GtkCellRenderer *cell,
+				 GtkWidget       *widget,
+				 GdkRectangle    *cell_area,
+				 gint            *x_offset,
+				 gint            *y_offset,
+				 gint            *width,
+				 gint            *height)
+{
+  KatzeCellRenderer2texts *celltext = (KatzeCellRenderer2texts *) cell;
+  KatzeCellRenderer2textsPrivate *priv;
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (cell);
+
+  set_text (celltext, widget, priv);
+
+  gtk_cell_renderer_get_size (GTK_CELL_RENDERER (priv->celltext),
+			      widget, cell_area,
+			      x_offset, y_offset, width, height);
+}
+
+static void
+#if GTK_CHECK_VERSION(3,0,0)
+katze_cell_renderer_2texts_render (GtkCellRenderer      *cell,
+			       cairo_t*             cr,
+			       GtkWidget            *widget,
+			       GdkRectangle         *background_area,
+			       GdkRectangle         *cell_area,
+			       GtkCellRendererState  flags)
+#else
+katze_cell_renderer_2texts_render (GtkCellRenderer      *cell,
+			       GdkDrawable          *window,
+			       GtkWidget            *widget,
+			       GdkRectangle         *background_area,
+			       GdkRectangle         *cell_area,
+			       GdkRectangle         *expose_area,
+			       GtkCellRendererState  flags)
+#endif
+{
+  KatzeCellRenderer2texts *celltext = (KatzeCellRenderer2texts *) cell;
+  KatzeCellRenderer2textsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (cell);
+
+  set_text (celltext, widget, priv);
+
+#if GTK_CHECK_VERSION(3,0,0)
+  gtk_cell_renderer_render (GTK_CELL_RENDERER (priv->celltext),
+			    cr,
+			    widget,
+			    background_area,
+			    cell_area,
+			    flags);
+#else
+  gtk_cell_renderer_render (GTK_CELL_RENDERER (priv->celltext),
+			    window,
+			    widget,
+			    background_area,
+			    cell_area,
+			    expose_area,
+			    flags);
+#endif
+}
+
+static void
+katze_cell_renderer_2texts_edited (GtkCellRendererText *celltext,
+				   const gchar* path,
+				   const gchar* new_text,
+				   gpointer         data)
+{
+  g_signal_emit (data, _2texts_cell_renderer_signals[EDITED], 0, path, new_text);
+}
+
+static GtkCellEditable *
+katze_cell_renderer_2texts_start_editing (GtkCellRenderer      *cell,
+				      GdkEvent             *event,
+				      GtkWidget            *widget,
+				      const gchar          *path,
+				      GdkRectangle         *background_area,
+				      GdkRectangle         *cell_area,
+				      GtkCellRendererState  flags)
+{
+  GtkCellEditable *celledit;
+  GtkRequisition requisition;
+  KatzeCellRenderer2texts *celltext;
+  KatzeCellRenderer2textsPrivate *priv;
+
+  celltext = KATZE_CELL_RENDERER_2TEXTS (cell);
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (cell);
+
+  celledit = gtk_cell_renderer_start_editing (GTK_CELL_RENDERER (priv->celltext), event, widget, path, background_area, cell_area, flags);
+
+  if (celledit)
+    g_signal_connect (priv->celltext,
+		      "edited",
+		      G_CALLBACK (katze_cell_renderer_2texts_edited),
+		      celltext);
+
+  return celledit;
+}
+
+/**
+ * katze_cell_renderer_2texts_set_fixed_height_from_font:
+ * @renderer: A #KatzeCellRenderer2texts
+ * @number_of_rows: Number of rows of text each cell renderer is allocated, or -1
+ *
+ * Sets the height of a renderer to explicitly be determined by the "font" and
+ * "y_pad" property set on it.  Further changes in these properties do not
+ * affect the height, so they must be accompanied by a subsequent call to this
+ * function.  Using this function is unflexible, and should really only be used
+ * if calculating the size of a cell is too slow (ie, a massive number of cells
+ * displayed).  If @number_of_rows is -1, then the fixed height is unset, and
+ * the height is determined by the properties again.
+ **/
+void
+katze_cell_renderer_2texts_set_fixed_height_from_font (KatzeCellRenderer2texts *renderer,
+						                               gint number_of_rows)
+{
+  g_return_if_fail (KATZE_IS_CELL_RENDERER_2TEXTS (renderer));
+  g_return_if_fail (number_of_rows == -1 || number_of_rows > 0);
+
+  KatzeCellRenderer2textsPrivate *priv;
+
+  priv = KATZE_CELL_RENDERER_2TEXTS_GET_PRIVATE (renderer);
+
+  gtk_cell_renderer_text_set_fixed_height_from_font (priv->celltext, number_of_rows);
+}
 
=== added file 'katze/katze-cellrenderer2texts.h'
--- katze/katze-cellrenderer2texts.h	1970-01-01 00:00:00 +0000
+++ katze/katze-cellrenderer2texts.h	2013-07-18 19:43:28 +0000
@@ -0,0 +1,71 @@
+/*
+ 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_2TEXTS_H__
+#define __KATZE_CELL_RENDERER_2TEXTS_H__
+
+
+#include <gtk/gtk.h>
+
+#ifndef GSEAL
+#define GSEAL(String) String
+#endif
+
+G_BEGIN_DECLS
+
+
+#define KATZE_TYPE_CELL_RENDERER_2TEXTS		(katze_cell_renderer_2texts_get_type ())
+#define KATZE_CELL_RENDERER_2TEXTS(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), KATZE_TYPE_CELL_RENDERER_2TEXTS, KatzeCellRenderer2texts))
+#define KATZE_CELL_RENDERER_2TEXTS_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), KATZE_TYPE_CELL_RENDERER_2TEXTS, KatzeCellRenderer2textsClass))
+#define KATZE_IS_CELL_RENDERER_2TEXTS(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), KATZE_TYPE_CELL_RENDERER_2TEXTS))
+#define KATZE_IS_CELL_RENDERER_2TEXTS_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), KATZE_TYPE_CELL_RENDERER_2TEXTS))
+#define KATZE_CELL_RENDERER_2TEXTS_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), KATZE_TYPE_CELL_RENDERER_2TEXTS, KatzeCellRenderer2textsClass))
+
+typedef struct _KatzeCellRenderer2texts      KatzeCellRenderer2texts;
+typedef struct _KatzeCellRenderer2textsClass KatzeCellRenderer2textsClass;
+
+struct _KatzeCellRenderer2texts
+{
+  GtkCellRenderer parent;
+
+  /*< private >*/
+  gchar *GSEAL (text);
+  PangoAttrList *GSEAL (extra_attrs);
+
+  gchar *GSEAL (alternate_text);
+  PangoAttrList *GSEAL (alternate_extra_attrs);
+};
+
+struct _KatzeCellRenderer2textsClass
+{
+  GtkCellRendererClass parent_class;
+
+  void (* edited) (KatzeCellRenderer2texts *cell_renderer_2texts,
+		   const gchar         *path,
+		   const gchar         *new_text);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+};
+
+GType            katze_cell_renderer_2texts_get_type (void) G_GNUC_CONST;
+GtkCellRenderer *katze_cell_renderer_2texts_new      (void);
+
+void             katze_cell_renderer_2texts_set_fixed_height_from_font (KatzeCellRenderer2texts *renderer,
+								    gint                 number_of_rows);
+
+
+G_END_DECLS
+
+#endif /* __KATZE_CELL_RENDERER_2TEXTS_H__ */
 
=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-07-15 23:01:23 +0000
+++ midori/midori-browser.c	2013-07-18 19:43:28 +0000
@@ -26,6 +26,8 @@
 #include "midori-privatedata.h"
 #include "midori-core.h"
 #include "midori-privatedata.h"
+#include "katze-cellrenderer2texts.h"
+#include "katze-cellrenderer2pixbufs.h"
 
 #include "marshal.h"
 
@@ -828,52 +830,221 @@
     }
 }
 
+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 = katze_cell_renderer_2pixbufs_new ();
+    g_object_set (G_OBJECT (renderer), 
+        "pixbuf-expander-open", 
+        gtk_widget_render_icon (GTK_WIDGET (combo), 
+            GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU, NULL),
+        "pixbuf-expander-closed", 
+        gtk_widget_render_icon (GTK_WIDGET (combo), 
+            GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL),
+        NULL);
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
+
+    renderer = katze_cell_renderer_2texts_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,
+        "alternate-text", _("Select this folder"),
+        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 +1058,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 +1186,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 +4624,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);