[gtk+/flowbox] Add GtkFlowBox



commit 9787aa2ef9610033ca94c677db486b429d004cb8
Author: Matthias Clasen <mclasen redhat com>
Date:   Sun Sep 29 13:43:27 2013 -0400

    Add GtkFlowBox
    
    GtkFlowBox is a container that its children in a reflowing
    grid, which can be oriented horizontally or vertically.
    
    It is similar to GtkListBox in that the children can
    be sorted and filtered, and by requiring a dedicated child
    widget type, GtkFlowBoxChild. It is similar to GtkTreeView
    in that is supports a full set of selection modes, including
    rubberband selection.
    
    This is the culmination of work that has happened in the
    egg-list-box module, and earlier in libegg. The origins of
    this code are the EggSpreadTable in libegg, which was written
    by Tristan van Berkom. It was moved to egg-list-box and
    renamed EggFlowBox by Jon McCann, and I gave it some finishing
    touched in the flowbox-improvements branch of that module.

 docs/reference/gtk/Makefile.am         |    3 +-
 docs/reference/gtk/gtk-docs.sgml       |    1 +
 docs/reference/gtk/gtk3-sections.txt   |   49 +
 docs/reference/gtk/gtk3.types.in       |    2 +
 docs/reference/gtk/images/flow-box.png |  Bin 0 -> 6359 bytes
 docs/reference/gtk/visual_index.xml    |    3 +
 docs/tools/widgets.c                   |   44 +
 gtk/Makefile.am                        |    2 +
 gtk/a11y/Makefile.am                   |    2 +
 gtk/a11y/gtkflowboxaccessible.c        |  254 ++
 gtk/a11y/gtkflowboxaccessible.h        |   58 +
 gtk/a11y/gtkflowboxaccessibleprivate.h |   30 +
 gtk/a11y/gtkflowboxchildaccessible.c   |   70 +
 gtk/a11y/gtkflowboxchildaccessible.h   |   55 +
 gtk/gtk-a11y.h                         |    2 +
 gtk/gtk.h                              |    1 +
 gtk/gtkflowbox.c                       | 4719 ++++++++++++++++++++++++++++++++
 gtk/gtkflowbox.h                       |  220 ++
 tests/Makefile.am                      |    5 +
 tests/testflowbox.c                    |  692 +++++
 20 files changed, 6211 insertions(+), 1 deletions(-)
---
diff --git a/docs/reference/gtk/Makefile.am b/docs/reference/gtk/Makefile.am
index 1c60e59..c1afc06 100644
--- a/docs/reference/gtk/Makefile.am
+++ b/docs/reference/gtk/Makefile.am
@@ -421,7 +421,8 @@ HTML_IMAGES = \
        $(srcdir)/images/getting-started-app7.png                       \
        $(srcdir)/images/getting-started-app8.png                       \
        $(srcdir)/images/getting-started-app9.png                       \
-       $(srcdir)/images/exampleapp.png
+       $(srcdir)/images/exampleapp.png                                 \
+       $(srcdir)/images/flow-box.png
 
 # Extra options to supply to gtkdoc-fixref
 FIXXREF_OPTIONS=--extra-dir=../gdk/html \
diff --git a/docs/reference/gtk/gtk-docs.sgml b/docs/reference/gtk/gtk-docs.sgml
index 9099510..3500804 100644
--- a/docs/reference/gtk/gtk-docs.sgml
+++ b/docs/reference/gtk/gtk-docs.sgml
@@ -72,6 +72,7 @@
       <xi:include href="xml/gtkgrid.xml" />
       <xi:include href="xml/gtkrevealer.xml" />
       <xi:include href="xml/gtklistbox.xml" />
+      <xi:include href="xml/gtkflowbox.xml" />
       <xi:include href="xml/gtkstack.xml" />
       <xi:include href="xml/gtkstackswitcher.xml" />
       <xi:include href="xml/gtkheaderbar.xml" />
diff --git a/docs/reference/gtk/gtk3-sections.txt b/docs/reference/gtk/gtk3-sections.txt
index 27bb480..88c251e 100644
--- a/docs/reference/gtk/gtk3-sections.txt
+++ b/docs/reference/gtk/gtk3-sections.txt
@@ -7737,3 +7737,52 @@ GtkRevealerTransitionType
 gtk_revealer_get_transition_type
 gtk_revealer_set_transition_type
 </SECTION>
+
+<SECTION>
+<FILE>gtkflowbox</FILE>
+<TITLE>GtkFlowBox</TITLE>
+GtkFlowBox
+gtk_flow_box_new
+gtk_flow_box_insert
+gtk_flow_box_get_child_at_index
+gtk_flow_box_set_hadjustment
+gtk_flow_box_set_vadjustment
+
+gtk_flow_box_set_homogeneous
+gtk_flow_box_get_homogeneous
+gtk_flow_box_set_row_spacing
+gtk_flow_box_get_row_spacing
+gtk_flow_box_set_column_spacing
+gtk_flow_box_get_column_spacing
+gtk_flow_box_set_min_children_per_line
+gtk_flow_box_get_min_children_per_line
+gtk_flow_box_set_max_children_per_line
+gtk_flow_box_get_max_children_per_line
+gtk_flow_box_set_activate_on_single_click
+gtk_flow_box_get_activate_on_single_click
+
+GtkFlowBoxForeachFunc
+gtk_flow_box_selected_foreach
+gtk_flow_box_get_selected_children
+gtk_flow_box_select_child
+gtk_flow_box_unselect_child
+gtk_flow_box_select_all
+gtk_flow_box_unselect_all
+gtk_flow_box_set_selection_mode
+gtk_flow_box_get_selection_mode
+
+GtkFlowBoxFilterFunc
+gtk_flow_box_set_filter_func
+gtk_flow_box_invalidate_filter
+
+GtkFlowBoxSortFunc
+gtk_flow_box_set_sort_func
+gtk_flow_box_invalidate_sort
+
+<SUBSECTION GtkFlowBoxChild>
+GtkFlowBoxChild
+gtk_flow_box_child_new
+gtk_flow_box_child_get_index
+gtk_flow_box_child_is_selected
+gtk_flow_box_child_changed
+</SECTION>
diff --git a/docs/reference/gtk/gtk3.types.in b/docs/reference/gtk/gtk3.types.in
index 6c37354..07ce0a8 100644
--- a/docs/reference/gtk/gtk3.types.in
+++ b/docs/reference/gtk/gtk3.types.in
@@ -70,6 +70,8 @@ gtk_file_chooser_get_type
 gtk_file_chooser_widget_get_type
 gtk_file_filter_get_type
 gtk_fixed_get_type
+gtk_flow_box_get_type
+gtk_flow_box_child_get_type
 gtk_font_button_get_type
 gtk_font_chooser_get_type
 gtk_font_chooser_dialog_get_type
diff --git a/docs/reference/gtk/images/flow-box.png b/docs/reference/gtk/images/flow-box.png
new file mode 100644
index 0000000..6ef99d3
Binary files /dev/null and b/docs/reference/gtk/images/flow-box.png differ
diff --git a/docs/reference/gtk/visual_index.xml b/docs/reference/gtk/visual_index.xml
index 2a64ad9..1df14dd 100644
--- a/docs/reference/gtk/visual_index.xml
+++ b/docs/reference/gtk/visual_index.xml
@@ -126,6 +126,9 @@
     <link linkend="GtkListBox">
       <inlinegraphic fileref="list-box.png" format="PNG"></inlinegraphic>
     </link>
+    <link linkend="GtkFlowBox">
+      <inlinegraphic fileref="flow-box.png" format="PNG"></inlinegraphic>
+    </link>
     <link linkend="GtkStack">
       <inlinegraphic fileref="stack.png" format="PNG"></inlinegraphic>
     </link>
diff --git a/docs/tools/widgets.c b/docs/tools/widgets.c
index 04af08b..76bd20e 100644
--- a/docs/tools/widgets.c
+++ b/docs/tools/widgets.c
@@ -1430,12 +1430,56 @@ create_list_box (void)
   return info;
 }
 
+static WidgetInfo *
+create_flow_box (void)
+{
+  GtkWidget *widget;
+  GtkWidget *box;
+  GtkWidget *vbox;
+  GtkWidget *child;
+  GtkWidget *button;
+  WidgetInfo *info;
+
+  widget = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (widget), GTK_SHADOW_IN);
+
+  box = gtk_flow_box_new ();
+  gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (box), 2);
+  gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (box), 2);
+  gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (box), GTK_SELECTION_BROWSE);
+  button = gtk_label_new ("Child One");
+  gtk_container_add (GTK_CONTAINER (box), button);
+  button = gtk_button_new_with_label ("Child Two");
+  gtk_container_add (GTK_CONTAINER (box), button);
+  child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+  gtk_container_add (GTK_CONTAINER (child), gtk_label_new ("Child Three"));
+  button = gtk_check_button_new ();
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
+  gtk_container_add (GTK_CONTAINER (child), button);
+  gtk_container_add (GTK_CONTAINER (box), child);
+  gtk_flow_box_select_child (GTK_FLOW_BOX (box),
+                             GTK_FLOW_BOX_CHILD (gtk_widget_get_parent (child)));
+
+  gtk_container_add (GTK_CONTAINER (widget), box);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+
+  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Flow Box"),
+                      FALSE, FALSE, 0);
+  info = new_widget_info ("flow-box", vbox, ASIS);
+  info->no_focus = FALSE;
+
+  return info;
+}
+
 GList *
 get_all_widgets (void)
 {
   GList *retval = NULL;
 
   retval = g_list_prepend (retval, create_list_box());
+  retval = g_list_prepend (retval, create_flow_box());
   retval = g_list_prepend (retval, create_headerbar ());
   retval = g_list_prepend (retval, create_placessidebar ());
   retval = g_list_prepend (retval, create_stack ());
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 8cfb620..b4ec377 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -249,6 +249,7 @@ gtk_public_h_sources =              \
        gtkfilechooserwidget.h  \
        gtkfilefilter.h         \
        gtkfixed.h              \
+       gtkflowbox.h            \
        gtkfontbutton.h         \
        gtkfontchooser.h        \
        gtkfontchooserdialog.h  \
@@ -741,6 +742,7 @@ gtk_base_c_sources =                \
        gtkfilesystem.c         \
        gtkfilesystemmodel.c    \
        gtkfixed.c              \
+       gtkflowbox.c            \
        gtkfontbutton.c         \
        gtkfontchooser.c        \
        gtkfontchooserdialog.c  \
diff --git a/gtk/a11y/Makefile.am b/gtk/a11y/Makefile.am
index 25205b3..2be4c99 100644
--- a/gtk/a11y/Makefile.am
+++ b/gtk/a11y/Makefile.am
@@ -18,6 +18,8 @@ gtka11y_c_sources =                   \
        gtkcontainercellaccessible.c    \
        gtkentryaccessible.c            \
        gtkexpanderaccessible.c         \
+       gtkflowboxaccessible.c          \
+       gtkflowboxchildaccessible.c     \
        gtkframeaccessible.c            \
        gtkiconviewaccessible.c         \
        gtkimageaccessible.c            \
diff --git a/gtk/a11y/gtkflowboxaccessible.c b/gtk/a11y/gtkflowboxaccessible.c
new file mode 100644
index 0000000..d32a7f2
--- /dev/null
+++ b/gtk/a11y/gtkflowboxaccessible.c
@@ -0,0 +1,254 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkflowboxaccessibleprivate.h"
+
+#include "gtk/gtkflowbox.h"
+
+static void atk_selection_interface_init (AtkSelectionIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GtkFlowBoxAccessible, gtk_flow_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
+
+static void
+gtk_flow_box_accessible_init (GtkFlowBoxAccessible *accessible)
+{
+}
+
+static void
+gtk_flow_box_accessible_initialize (AtkObject *obj,
+                                    gpointer   data)
+{
+  ATK_OBJECT_CLASS (gtk_flow_box_accessible_parent_class)->initialize (obj, data);
+
+  obj->role = ATK_ROLE_TABLE;
+}
+
+static AtkStateSet*
+gtk_flow_box_accessible_ref_state_set (AtkObject *obj)
+{
+  AtkStateSet *state_set;
+  GtkWidget *widget;
+
+  state_set = ATK_OBJECT_CLASS (gtk_flow_box_accessible_parent_class)->ref_state_set (obj);
+  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
+
+  if (widget != NULL)
+    atk_state_set_add_state (state_set, ATK_STATE_MANAGES_DESCENDANTS);
+
+  return state_set;
+}
+
+static void
+gtk_flow_box_accessible_class_init (GtkFlowBoxAccessibleClass *klass)
+{
+  AtkObjectClass *object_class = ATK_OBJECT_CLASS (klass);
+
+  object_class->initialize = gtk_flow_box_accessible_initialize;
+  object_class->ref_state_set = gtk_flow_box_accessible_ref_state_set;
+}
+
+static gboolean
+gtk_flow_box_accessible_add_selection (AtkSelection *selection,
+                                       gint          idx)
+{
+  GtkWidget *box;
+  GList *children;
+  GtkWidget *child;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return FALSE;
+
+  children = gtk_container_get_children (GTK_CONTAINER (box));
+  child = g_list_nth_data (children, idx);
+  g_list_free (children);
+  if (child)
+    {
+      gtk_flow_box_select_child (GTK_FLOW_BOX (box), GTK_FLOW_BOX_CHILD (child));
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_accessible_remove_selection (AtkSelection *selection,
+                                          gint          idx)
+{
+  GtkWidget *box;
+  GList *children;
+  GtkWidget *child;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return FALSE;
+
+  children = gtk_container_get_children (GTK_CONTAINER (box));
+  child = g_list_nth_data (children, idx);
+  g_list_free (children);
+  if (child)
+    {
+      gtk_flow_box_unselect_child (GTK_FLOW_BOX (box), GTK_FLOW_BOX_CHILD (child));
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_accessible_clear_selection (AtkSelection *selection)
+{
+  GtkWidget *box;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return FALSE;
+
+  gtk_flow_box_unselect_all (GTK_FLOW_BOX (box));
+  return TRUE;
+}
+
+static gboolean
+gtk_flow_box_accessible_select_all (AtkSelection *selection)
+{
+  GtkWidget *box;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return FALSE;
+
+  gtk_flow_box_select_all (GTK_FLOW_BOX (box));
+  return TRUE;
+}
+
+typedef struct
+{
+  gint idx;
+  GtkWidget *child;
+} FindSelectedData;
+
+static void
+find_selected_child (GtkFlowBox      *box,
+                     GtkFlowBoxChild *child,
+                     gpointer         data)
+{
+  FindSelectedData *d = data;
+
+  if (d->idx == 0)
+    {
+      if (d->child == NULL)
+        d->child = GTK_WIDGET (child);
+    }
+  else
+    d->idx -= 1;
+}
+
+static AtkObject *
+gtk_flow_box_accessible_ref_selection (AtkSelection *selection,
+                                       gint          idx)
+{
+  GtkWidget *box;
+  AtkObject *accessible;
+  FindSelectedData data;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return NULL;
+
+  data.idx = idx;
+  data.child = NULL;
+  gtk_flow_box_selected_foreach (GTK_FLOW_BOX (box), find_selected_child, &data);
+
+  if (data.child == NULL)
+    return NULL;
+
+  accessible = gtk_widget_get_accessible (data.child);
+  g_object_ref (accessible);
+  return accessible;
+}
+
+static void
+count_selected (GtkFlowBox      *box,
+                GtkFlowBoxChild *child,
+                gpointer         data)
+{
+  gint *count = data;
+  *count += 1;
+}
+
+static gint
+gtk_flow_box_accessible_get_selection_count (AtkSelection *selection)
+{
+  GtkWidget *box;
+  gint count;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return 0;
+
+  count = 0;
+  gtk_flow_box_selected_foreach (GTK_FLOW_BOX (box), count_selected, &count);
+
+  return count;
+}
+
+static gboolean
+gtk_flow_box_accessible_is_child_selected (AtkSelection *selection,
+                                           gint          idx)
+{
+  GtkWidget *box;
+  GtkFlowBoxChild *child;
+
+  box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
+  if (box == NULL)
+    return FALSE;
+
+  child = gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (box), idx);
+
+  return gtk_flow_box_child_is_selected (child);
+}
+
+static void atk_selection_interface_init (AtkSelectionIface *iface)
+{
+  iface->add_selection = gtk_flow_box_accessible_add_selection;
+  iface->remove_selection = gtk_flow_box_accessible_remove_selection;
+  iface->clear_selection = gtk_flow_box_accessible_clear_selection;
+  iface->ref_selection = gtk_flow_box_accessible_ref_selection;
+  iface->get_selection_count = gtk_flow_box_accessible_get_selection_count;
+  iface->is_child_selected = gtk_flow_box_accessible_is_child_selected;
+  iface->select_all_selection = gtk_flow_box_accessible_select_all;
+}
+
+void
+_gtk_flow_box_accessible_selection_changed (GtkWidget *box)
+{
+  AtkObject *accessible;
+  accessible = gtk_widget_get_accessible (box);
+  g_signal_emit_by_name (accessible, "selection-changed");
+}
+
+void
+_gtk_flow_box_accessible_update_cursor (GtkWidget *box,
+                                        GtkWidget *child)
+{
+  AtkObject *accessible;
+  AtkObject *descendant;
+  accessible = gtk_widget_get_accessible (box);
+  descendant = child ? gtk_widget_get_accessible (child) : NULL;
+  g_signal_emit_by_name (accessible, "active-descendant-changed", descendant);
+}
diff --git a/gtk/a11y/gtkflowboxaccessible.h b/gtk/a11y/gtkflowboxaccessible.h
new file mode 100644
index 0000000..5194572
--- /dev/null
+++ b/gtk/a11y/gtkflowboxaccessible.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_FLOW_BOX_ACCESSIBLE_H__
+#define __GTK_FLOW_BOX_ACCESSIBLE_H__
+
+#if !defined (__GTK_A11Y_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk-a11y.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+#include <gtk/a11y/gtkcontaineraccessible.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_FLOW_BOX_ACCESSIBLE                   (gtk_flow_box_accessible_get_type ())
+#define GTK_FLOW_BOX_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
GTK_TYPE_FLOW_BOX_ACCESSIBLE, GtkFlowBoxAccessible))
+#define GTK_FLOW_BOX_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), 
GTK_TYPE_FLOW_BOX_ACCESSIBLE, GtkFlowBoxAccessibleClass))
+#define GTK_IS_FLOW_BOX_ACCESSIBLE(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
GTK_TYPE_FLOW_BOX_ACCESSIBLE))
+#define GTK_IS_FLOW_BOX_ACCESSIBLE_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), 
GTK_TYPE_FLOW_BOX_ACCESSIBLE))
+#define GTK_FLOW_BOX_ACCESSIBLE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), 
GTK_TYPE_FLOW_BOX_ACCESSIBLE, GtkFlowBoxAccessibleClass))
+
+typedef struct _GtkFlowBoxAccessible        GtkFlowBoxAccessible;
+typedef struct _GtkFlowBoxAccessibleClass   GtkFlowBoxAccessibleClass;
+typedef struct _GtkFlowBoxAccessiblePrivate GtkFlowBoxAccessiblePrivate;
+
+struct _GtkFlowBoxAccessible
+{
+  GtkContainerAccessible parent;
+
+  GtkFlowBoxAccessiblePrivate *priv;
+};
+
+struct _GtkFlowBoxAccessibleClass
+{
+  GtkContainerAccessibleClass parent_class;
+};
+
+GDK_AVAILABLE_IN_3_12
+GType gtk_flow_box_accessible_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GTK_FLOW_BOX_ACCESSIBLE_H__ */
diff --git a/gtk/a11y/gtkflowboxaccessibleprivate.h b/gtk/a11y/gtkflowboxaccessibleprivate.h
new file mode 100644
index 0000000..df19ba7
--- /dev/null
+++ b/gtk/a11y/gtkflowboxaccessibleprivate.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_FLOW_BOX_ACCESSIBLE_PRIVATE_H__
+#define __GTK_FLOW_BOX_ACCESSIBLE_PRIVATE_H__
+
+#include <gtk/a11y/gtkflowboxaccessible.h>
+
+G_BEGIN_DECLS
+
+void _gtk_flow_box_accessible_selection_changed (GtkWidget *box);
+void _gtk_flow_box_accessible_update_cursor     (GtkWidget *box,
+                                                 GtkWidget *child);
+G_END_DECLS
+
+#endif /* __GTK_FLOW_BOX_ACCESSIBLE_PRIVATE_H__ */
diff --git a/gtk/a11y/gtkflowboxchildaccessible.c b/gtk/a11y/gtkflowboxchildaccessible.c
new file mode 100644
index 0000000..2476f97
--- /dev/null
+++ b/gtk/a11y/gtkflowboxchildaccessible.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkflowboxchildaccessible.h"
+
+#include "gtk/gtkflowbox.h"
+
+
+G_DEFINE_TYPE (GtkFlowBoxChildAccessible, gtk_flow_box_child_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+
+static void
+gtk_flow_box_child_accessible_init (GtkFlowBoxChildAccessible *accessible)
+{
+}
+
+static void
+gtk_flow_box_child_accessible_initialize (AtkObject *obj,
+                                          gpointer   data)
+{
+  ATK_OBJECT_CLASS (gtk_flow_box_child_accessible_parent_class)->initialize (obj, data);
+
+  obj->role = ATK_ROLE_TABLE_CELL;
+}
+
+static AtkStateSet *
+gtk_flow_box_child_accessible_ref_state_set (AtkObject *obj)
+{
+  AtkStateSet *state_set;
+  GtkWidget *widget, *parent;
+
+  state_set = ATK_OBJECT_CLASS (gtk_flow_box_child_accessible_parent_class)->ref_state_set (obj);
+
+  widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
+  if (widget != NULL)
+    {
+      parent = gtk_widget_get_parent (widget);
+      if (gtk_flow_box_get_selection_mode (GTK_FLOW_BOX (parent)) != GTK_SELECTION_NONE)
+        atk_state_set_add_state (state_set, ATK_STATE_SELECTABLE);
+
+      if (gtk_flow_box_child_is_selected (GTK_FLOW_BOX_CHILD (widget)))
+        atk_state_set_add_state (state_set, ATK_STATE_SELECTED);
+    }
+
+  return state_set;
+}
+
+static void
+gtk_flow_box_child_accessible_class_init (GtkFlowBoxChildAccessibleClass *klass)
+{
+  AtkObjectClass *object_class = ATK_OBJECT_CLASS (klass);
+
+  object_class->initialize = gtk_flow_box_child_accessible_initialize;
+  object_class->ref_state_set = gtk_flow_box_child_accessible_ref_state_set;
+}
diff --git a/gtk/a11y/gtkflowboxchildaccessible.h b/gtk/a11y/gtkflowboxchildaccessible.h
new file mode 100644
index 0000000..0a52d33
--- /dev/null
+++ b/gtk/a11y/gtkflowboxchildaccessible.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * 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 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_FLOW_BOX_CHILD_ACCESSIBLE_H__
+#define __GTK_FLOW_BOX_CHILD_ACCESSIBLE_H__
+
+#if !defined (__GTK_A11Y_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk-a11y.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+#include <gtk/a11y/gtkcontaineraccessible.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE               (gtk_flow_box_child_accessible_get_type ())
+#define GTK_FLOW_BOX_CHILD_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE, GtkFlowBoxChildAccessible))
+#define GTK_FLOW_BOX_CHILD_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), 
GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE, GtkFlowBoxChildAccessibleClass))
+#define GTK_IS_FLOW_BOX_CHILD_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE))
+#define GTK_IS_FLOW_BOX_CHILD_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), 
GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE))
+#define GTK_FLOW_BOX_CHILD_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), 
GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE, GtkFlowBoxChildAccessibleClass))
+
+typedef struct _GtkFlowBoxChildAccessible        GtkFlowBoxChildAccessible;
+typedef struct _GtkFlowBoxChildAccessibleClass   GtkFlowBoxChildAccessibleClass;
+
+struct _GtkFlowBoxChildAccessible
+{
+  GtkContainerAccessible parent;
+};
+
+struct _GtkFlowBoxChildAccessibleClass
+{
+  GtkContainerAccessibleClass parent_class;
+};
+
+GDK_AVAILABLE_IN_3_12
+GType gtk_flow_box_child_accessible_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GTK_FLOW_BOX_CHILD_ACCESSIBLE_H__ */
diff --git a/gtk/gtk-a11y.h b/gtk/gtk-a11y.h
index ba46bcd..8e395a6 100644
--- a/gtk/gtk-a11y.h
+++ b/gtk/gtk-a11y.h
@@ -39,6 +39,8 @@
 #include <gtk/a11y/gtkcontainercellaccessible.h>
 #include <gtk/a11y/gtkentryaccessible.h>
 #include <gtk/a11y/gtkexpanderaccessible.h>
+#include <gtk/a11y/gtkflowboxaccessible.h>
+#include <gtk/a11y/gtkflowboxchildaccessible.h>
 #include <gtk/a11y/gtkframeaccessible.h>
 #include <gtk/a11y/gtkiconviewaccessible.h>
 #include <gtk/a11y/gtkimageaccessible.h>
diff --git a/gtk/gtk.h b/gtk/gtk.h
index fa20539..a3413db 100644
--- a/gtk/gtk.h
+++ b/gtk/gtk.h
@@ -99,6 +99,7 @@
 #include <gtk/gtkfilechooserdialog.h>
 #include <gtk/gtkfilechooserwidget.h>
 #include <gtk/gtkfilefilter.h>
+#include <gtk/gtkflowbox.h>
 #include <gtk/gtkfontbutton.h>
 #include <gtk/gtkfontchooser.h>
 #include <gtk/gtkfontchooserdialog.h>
diff --git a/gtk/gtkflowbox.c b/gtk/gtkflowbox.c
new file mode 100644
index 0000000..436ac9f
--- /dev/null
+++ b/gtk/gtkflowbox.c
@@ -0,0 +1,4719 @@
+/*
+ * Copyright (C) 2007-2010 Openismus GmbH
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Authors:
+ *      Tristan Van Berkom <tristanvb openismus com>
+ *      Matthias Clasen <mclasen redhat com>
+ *      William Jon McCann <jmccann redhat com>
+ */
+
+/* Preamble {{{1 */
+
+/**
+ * SECTION:gtkflowbox
+ * @Short_Description: A container that allows reflowing its children
+ * @Title: GtkFlowBox
+ *
+ * An GtkFlowBox positions child widgets in sequence according to its
+ * orientation.
+ *
+ * For instance, with the horizontal orientation, the widgets will be
+ * arranged from left to right, starting a new row under the previous
+ * row when necessary. Reducing the width in this case will require more
+ * rows, so a larger height will be requested.
+ *
+ * Likewise, with the vertical orientation, the widgets will be arranged
+ * from top to bottom, starting a new column to the right when necessary.
+ * Reducing the height will require more columns, so a larger width will
+ * be requested.
+ *
+ * The children of a GtkFlowBox can be dynamically sorted and filtered.
+ *
+ * Although a GtkFlowBox must have only #GtkFlowBoxChild children,
+ * you can add any kind of widget to it via gtk_container_add(), and
+ * a GtkFlowBoxChild widget will automatically be inserted between
+ * the box and the widget.
+ *
+ * Also see #GtkListBox.
+ *
+ * GtkFlowBox was added in GTK+ 3.12.
+ */
+
+#include <config.h>
+
+#include "gtkflowbox.h"
+#include "gtkmarshalers.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
+
+#include "a11y/gtkflowboxaccessibleprivate.h"
+#include "a11y/gtkflowboxchildaccessible.h"
+
+/* Forward declarations and utilities {{{1 */
+
+static void gtk_flow_box_update_cursor       (GtkFlowBox      *box,
+                                              GtkFlowBoxChild *child);
+static void gtk_flow_box_select_and_activate (GtkFlowBox      *box,
+                                              GtkFlowBoxChild *child);
+static void gtk_flow_box_update_selection    (GtkFlowBox      *box,
+                                              GtkFlowBoxChild *child,
+                                              gboolean         modify,
+                                              gboolean         extend);
+static void gtk_flow_box_apply_filter        (GtkFlowBox      *box,
+                                              GtkFlowBoxChild *child);
+static void gtk_flow_box_apply_sort          (GtkFlowBox      *box,
+                                              GtkFlowBoxChild *child);
+static gint gtk_flow_box_sort                (GtkFlowBoxChild *a,
+                                              GtkFlowBoxChild *b,
+                                              GtkFlowBox      *box);
+
+static void
+get_current_selection_modifiers (GtkWidget *widget,
+                                 gboolean  *modify,
+                                 gboolean  *extend)
+{
+  GdkModifierType state = 0;
+  GdkModifierType mask;
+
+  *modify = FALSE;
+  *extend = FALSE;
+
+  if (gtk_get_current_event_state (&state))
+    {
+      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+      if ((state & mask) == mask)
+        *modify = TRUE;
+      mask = gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      if ((state & mask) == mask)
+        *extend = TRUE;
+    }
+}
+
+static void
+path_from_horizontal_line_rects (cairo_t      *cr,
+                                 GdkRectangle *lines,
+                                 gint          n_lines)
+{
+  gint start_line, end_line;
+  GdkRectangle *r;
+  gint i;
+
+  /* Join rows vertically by extending to the middle */
+  for (i = 0; i < n_lines - 1; i++)
+    {
+      GdkRectangle *r1 = &lines[i];
+      GdkRectangle *r2 = &lines[i+1];
+      gint gap, old;
+
+      gap = r2->y - (r1->y + r1->height);
+      r1->height += gap / 2;
+      old = r2->y;
+      r2->y = r1->y + r1->height;
+      r2->height += old - r2->y;
+    }
+
+  cairo_new_path (cr);
+  start_line = 0;
+
+  do
+    {
+      for (i = start_line; i < n_lines; i++)
+        {
+          r = &lines[i];
+          if (i == start_line)
+            cairo_move_to (cr, r->x + r->width, r->y);
+          else
+            cairo_line_to (cr, r->x + r->width, r->y);
+          cairo_line_to (cr, r->x + r->width, r->y + r->height);
+
+          if (i < n_lines - 1 &&
+              (r->x + r->width < lines[i+1].x ||
+              r->x > lines[i+1].x + lines[i+1].width))
+            {
+              i++;
+              break;
+            }
+        }
+      end_line = i;
+      for (i = end_line - 1; i >= start_line; i--)
+        {
+          r = &lines[i];
+          cairo_line_to (cr, r->x, r->y + r->height);
+          cairo_line_to (cr, r->x, r->y);
+        }
+      cairo_close_path (cr);
+      start_line = end_line;
+    }
+  while (end_line < n_lines);
+}
+
+static void
+path_from_vertical_line_rects (cairo_t      *cr,
+                               GdkRectangle *lines,
+                               gint          n_lines)
+{
+  gint start_line, end_line;
+  GdkRectangle *r;
+  gint i;
+
+  /* Join rows horizontally by extending to the middle */
+  for (i = 0; i < n_lines - 1; i++)
+    {
+      GdkRectangle *r1 = &lines[i];
+      GdkRectangle *r2 = &lines[i+1];
+      gint gap, old;
+
+      gap = r2->x - (r1->x + r1->width);
+      r1->width += gap / 2;
+      old = r2->x;
+      r2->x = r1->x + r1->width;
+      r2->width += old - r2->x;
+    }
+
+  cairo_new_path (cr);
+  start_line = 0;
+
+  do
+    {
+      for (i = start_line; i < n_lines; i++)
+        {
+          r = &lines[i];
+          if (i == start_line)
+            cairo_move_to (cr, r->x, r->y + r->height);
+          else
+            cairo_line_to (cr, r->x, r->y + r->height);
+          cairo_line_to (cr, r->x + r->width, r->y + r->height);
+
+          if (i < n_lines - 1 &&
+              (r->y + r->height < lines[i+1].y ||
+              r->y > lines[i+1].y + lines[i+1].height))
+            {
+              i++;
+              break;
+            }
+        }
+      end_line = i;
+      for (i = end_line - 1; i >= start_line; i--)
+        {
+          r = &lines[i];
+          cairo_line_to (cr, r->x + r->width, r->y);
+          cairo_line_to (cr, r->x, r->y);
+        }
+      cairo_close_path (cr);
+      start_line = end_line;
+    }
+  while (end_line < n_lines);
+}
+
+/* GtkFlowBoxChild {{{1 */
+
+/* GObject boilerplate {{{2 */
+
+enum {
+  CHILD_ACTIVATE,
+  CHILD_LAST_SIGNAL
+};
+
+static guint child_signals[CHILD_LAST_SIGNAL] = { 0 };
+
+typedef struct _GtkFlowBoxChildPrivate GtkFlowBoxChildPrivate;
+struct _GtkFlowBoxChildPrivate
+{
+  GSequenceIter *iter;
+  gboolean       selected;
+};
+
+#define CHILD_PRIV(child) ((GtkFlowBoxChildPrivate*)gtk_flow_box_child_get_instance_private 
((GtkFlowBoxChild*)(child)))
+
+G_DEFINE_TYPE_WITH_PRIVATE (GtkFlowBoxChild, gtk_flow_box_child, GTK_TYPE_BIN)
+
+/* Internal API {{{2 */
+
+static GtkFlowBox *
+gtk_flow_box_child_get_box (GtkFlowBoxChild *child)
+{
+  GtkWidget *parent;
+
+  parent = gtk_widget_get_parent (GTK_WIDGET (child));
+  if (parent && GTK_IS_FLOW_BOX (parent))
+    return GTK_FLOW_BOX (parent);
+
+  return NULL;
+}
+
+static void
+gtk_flow_box_child_set_focus (GtkFlowBoxChild *child)
+{
+  GtkFlowBox *box = gtk_flow_box_child_get_box (child);
+  gboolean modify_selection;
+  gboolean extend_selection;
+
+  get_current_selection_modifiers (GTK_WIDGET (box), &modify_selection, &extend_selection);
+
+  if (modify_selection)
+    gtk_flow_box_update_cursor (box, child);
+  else
+    gtk_flow_box_update_selection (box, child, FALSE, FALSE);
+}
+
+/* GtkWidget implementation {{{2 */
+
+static gboolean
+gtk_flow_box_child_focus (GtkWidget        *widget,
+                          GtkDirectionType  direction)
+{
+  gboolean had_focus = FALSE;
+  GtkWidget *child;
+
+  child = gtk_bin_get_child (GTK_BIN (widget));
+
+  g_object_get (widget, "has-focus", &had_focus, NULL);
+  if (had_focus)
+    {
+      /* If on row, going right, enter into possible container */
+      if (child &&
+          (direction == GTK_DIR_RIGHT || direction == GTK_DIR_TAB_FORWARD))
+        {
+          if (gtk_widget_child_focus (GTK_WIDGET (child), direction))
+            return TRUE;
+        }
+
+      return FALSE;
+    }
+  else if (gtk_container_get_focus_child (GTK_CONTAINER (widget)) != NULL)
+    {
+      /* Child has focus, always navigate inside it first */
+      if (gtk_widget_child_focus (child, direction))
+        return TRUE;
+
+      /* If exiting child container to the left, select child  */
+      if (direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD)
+        {
+          gtk_flow_box_child_set_focus (GTK_FLOW_BOX_CHILD (widget));
+          return TRUE;
+        }
+
+      return FALSE;
+    }
+  else
+    {
+      /* If coming from the left, enter into possible container */
+      if (child &&
+          (direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD))
+        {
+          if (gtk_widget_child_focus (child, direction))
+            return TRUE;
+        }
+
+      gtk_flow_box_child_set_focus (GTK_FLOW_BOX_CHILD (widget));
+      return TRUE;
+    }
+}
+
+static void
+gtk_flow_box_child_activate (GtkFlowBoxChild *child)
+{
+  GtkFlowBox *box;
+
+  box = gtk_flow_box_child_get_box (child);
+  if (box)
+    gtk_flow_box_select_and_activate (box, child);
+}
+
+static gboolean
+gtk_flow_box_child_draw (GtkWidget *widget,
+                         cairo_t   *cr)
+{
+  GtkAllocation allocation = {0};
+  GtkStyleContext* context;
+  GtkStateFlags state;
+  GtkBorder border;
+  gint focus_pad;
+
+  gtk_widget_get_allocation (widget, &allocation);
+  context = gtk_widget_get_style_context (widget);
+  state = gtk_widget_get_state_flags (widget);
+
+  gtk_render_background (context, cr, 0, 0, allocation.width, allocation.height);
+  gtk_render_frame (context, cr, 0, 0, allocation.width, allocation.height);
+
+  if (gtk_widget_has_visible_focus (widget))
+    {
+      gtk_style_context_get_border (context, state, &border);
+
+      gtk_style_context_get_style (context,
+                                   "focus-padding", &focus_pad,
+                                   NULL);
+      gtk_render_focus (context, cr, border.left + focus_pad, border.top + focus_pad,
+                        allocation.width - 2 * focus_pad - border.left - border.right,
+                        allocation.height - 2 * focus_pad - border.top - border.bottom);
+    }
+
+  GTK_WIDGET_CLASS (gtk_flow_box_child_parent_class)->draw (widget, cr);
+
+  return TRUE;
+}
+
+/* Size allocation {{{3 */
+
+static void
+gtk_flow_box_child_get_full_border (GtkFlowBoxChild *child,
+                                    GtkBorder       *full_border)
+{
+  GtkWidget *widget = GTK_WIDGET (child);
+  GtkStyleContext *context;
+  GtkStateFlags state;
+  GtkBorder padding, border;
+  int focus_width, focus_pad;
+
+  context = gtk_widget_get_style_context (widget);
+  state = gtk_style_context_get_state (context);
+
+  gtk_style_context_get_padding (context, state, &padding);
+  gtk_style_context_get_border (context, state, &border);
+  gtk_style_context_get_style (context,
+                               "focus-line-width", &focus_width,
+                               "focus-padding", &focus_pad,
+                               NULL);
+
+  full_border->left = padding.left + border.left + focus_width + focus_pad;
+  full_border->right = padding.right + border.right + focus_width + focus_pad;
+  full_border->top = padding.top + border.top + focus_width + focus_pad;
+  full_border->bottom = padding.bottom + border.bottom + focus_width + focus_pad;
+}
+
+static GtkSizeRequestMode
+gtk_flow_box_child_get_request_mode (GtkWidget *widget)
+{
+  GtkFlowBox *box;
+
+  box = gtk_flow_box_child_get_box (GTK_FLOW_BOX_CHILD (widget));
+  if (box)
+    return gtk_widget_get_request_mode (GTK_WIDGET (box));
+  else
+    return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
+}
+
+static void gtk_flow_box_child_get_preferred_width_for_height (GtkWidget *widget,
+                                                               gint       height,
+                                                               gint      *minimum_width,
+                                                               gint      *natural_width);
+static void gtk_flow_box_child_get_preferred_height           (GtkWidget *widget,
+                                                               gint      *minimum_height,
+                                                               gint      *natural_height);
+
+static void
+gtk_flow_box_child_get_preferred_height_for_width (GtkWidget *widget,
+                                                   gint       width,
+                                                   gint      *minimum_height,
+                                                   gint      *natural_height)
+{
+  if (gtk_flow_box_child_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+    {
+      GtkWidget *child;
+      gint child_min = 0, child_natural = 0;
+      GtkBorder full_border = { 0, };
+
+      gtk_flow_box_child_get_full_border (GTK_FLOW_BOX_CHILD (widget), &full_border);
+      child = gtk_bin_get_child (GTK_BIN (widget));
+      if (child && gtk_widget_get_visible (child))
+        gtk_widget_get_preferred_height_for_width (child, width - full_border.left - full_border.right,
+                                                   &child_min, &child_natural);
+
+      if (minimum_height)
+        *minimum_height = full_border.top + child_min + full_border.bottom;
+      if (natural_height)
+        *natural_height = full_border.top + child_natural + full_border.bottom;
+    }
+  else
+    {
+      gtk_flow_box_child_get_preferred_height (widget, minimum_height, natural_height);
+    }
+}
+
+static void
+gtk_flow_box_child_get_preferred_width (GtkWidget *widget,
+                                        gint      *minimum_width,
+                                        gint      *natural_width)
+{
+  if (gtk_flow_box_child_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+    {
+      GtkWidget *child;
+      gint child_min = 0, child_natural = 0;
+      GtkBorder full_border = { 0, };
+
+      gtk_flow_box_child_get_full_border (GTK_FLOW_BOX_CHILD (widget), &full_border);
+      child = gtk_bin_get_child (GTK_BIN (widget));
+      if (child && gtk_widget_get_visible (child))
+        gtk_widget_get_preferred_width (child, &child_min, &child_natural);
+
+      if (minimum_width)
+        *minimum_width = full_border.left + child_min + full_border.right;
+      if (natural_width)
+        *natural_width = full_border.left + child_natural + full_border.right;
+    }
+  else
+    {
+      gint natural_height;
+
+      gtk_flow_box_child_get_preferred_height (widget, NULL, &natural_height);
+      gtk_flow_box_child_get_preferred_width_for_height (widget, natural_height,
+                                                         minimum_width, natural_width);
+    }
+}
+
+static void
+gtk_flow_box_child_get_preferred_width_for_height (GtkWidget *widget,
+                                                   gint       height,
+                                                   gint      *minimum_width,
+                                                   gint      *natural_width)
+{
+  if (gtk_flow_box_child_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+    {
+      gtk_flow_box_child_get_preferred_width (widget, minimum_width, natural_width);
+    }
+  else
+    {
+      GtkWidget *child;
+      gint child_min = 0, child_natural = 0;
+      GtkBorder full_border = { 0, };
+
+      gtk_flow_box_child_get_full_border (GTK_FLOW_BOX_CHILD (widget), &full_border);
+      child = gtk_bin_get_child (GTK_BIN (widget));
+      if (child && gtk_widget_get_visible (child))
+        gtk_widget_get_preferred_width_for_height (child, height - full_border.top - full_border.bottom,
+                                                   &child_min, &child_natural);
+
+      if (minimum_width)
+        *minimum_width = full_border.left + child_min + full_border.right;
+      if (natural_width)
+        *natural_width = full_border.left + child_natural + full_border.right;
+    }
+}
+
+static void
+gtk_flow_box_child_get_preferred_height (GtkWidget *widget,
+                                         gint      *minimum_height,
+                                         gint      *natural_height)
+{
+  if (gtk_flow_box_child_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+    {
+      gint natural_width;
+
+      gtk_flow_box_child_get_preferred_width (widget, NULL, &natural_width);
+      gtk_flow_box_child_get_preferred_height_for_width (widget, natural_width,
+                                                         minimum_height, natural_height);
+    }
+  else
+    {
+      GtkWidget *child;
+      gint child_min = 0, child_natural = 0;
+      GtkBorder full_border = { 0, };
+
+      gtk_flow_box_child_get_full_border (GTK_FLOW_BOX_CHILD (widget), &full_border);
+      child = gtk_bin_get_child (GTK_BIN (widget));
+      if (child && gtk_widget_get_visible (child))
+        gtk_widget_get_preferred_height (child, &child_min, &child_natural);
+
+      if (minimum_height)
+        *minimum_height = full_border.top + child_min + full_border.bottom;
+      if (natural_height)
+        *natural_height = full_border.top + child_natural + full_border.bottom;
+    }
+}
+
+static void
+gtk_flow_box_child_size_allocate (GtkWidget     *widget,
+                                  GtkAllocation *allocation)
+{
+  GtkWidget *child;
+
+  gtk_widget_set_allocation (widget, allocation);
+
+  child = gtk_bin_get_child (GTK_BIN (widget));
+  if (child && gtk_widget_get_visible (child))
+    {
+      GtkAllocation child_allocation;
+      GtkBorder border = { 0, };
+
+      gtk_flow_box_child_get_full_border (GTK_FLOW_BOX_CHILD (widget), &border);
+
+      child_allocation.x = allocation->x + border.left;
+      child_allocation.y = allocation->y + border.top;
+      child_allocation.width = allocation->width - border.left - border.right;
+      child_allocation.height = allocation->height - border.top - border.bottom;
+
+      child_allocation.width  = MAX (1, child_allocation.width);
+      child_allocation.height = MAX (1, child_allocation.height);
+
+      gtk_widget_size_allocate (child, &child_allocation);
+    }
+}
+
+/* GObject implementation {{{2 */
+
+static void
+gtk_flow_box_child_class_init (GtkFlowBoxChildClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  widget_class->draw = gtk_flow_box_child_draw;
+  widget_class->get_request_mode = gtk_flow_box_child_get_request_mode;
+  widget_class->get_preferred_height = gtk_flow_box_child_get_preferred_height;
+  widget_class->get_preferred_height_for_width = gtk_flow_box_child_get_preferred_height_for_width;
+  widget_class->get_preferred_width = gtk_flow_box_child_get_preferred_width;
+  widget_class->get_preferred_width_for_height = gtk_flow_box_child_get_preferred_width_for_height;
+  widget_class->size_allocate = gtk_flow_box_child_size_allocate;
+  widget_class->focus = gtk_flow_box_child_focus;
+
+  class->activate = gtk_flow_box_child_activate;
+
+  /**
+   * GtkFlowBoxChild::activate:
+   * @child: The child on which the signal is emitted
+   *
+   * The ::activate signal is emitted when the user activates
+   * a child widget in a #GtkFlowBox, either by clicking or
+   * double-clicking, or by using the Space or Enter key.
+   *
+   * While this signal is used as a
+   * <link linkend="keybinding-signals">keybinding signal</link>,
+   * it can be used by applications for their own purposes.
+   */
+  child_signals[CHILD_ACTIVATE] =
+    g_signal_new (I_("activate"),
+                  G_OBJECT_CLASS_TYPE (object_class),
+                  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+                  G_STRUCT_OFFSET (GtkFlowBoxChildClass, activate),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+  widget_class->activate_signal = child_signals[CHILD_ACTIVATE];
+
+  gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_LIST_ITEM);
+}
+
+static void
+gtk_flow_box_child_init (GtkFlowBoxChild *child)
+{
+  GtkStyleContext *context;
+
+  gtk_widget_set_can_focus (GTK_WIDGET (child), TRUE);
+  gtk_widget_set_redraw_on_allocate (GTK_WIDGET (child), TRUE);
+
+  context = gtk_widget_get_style_context (GTK_WIDGET (child));
+  gtk_style_context_add_class (context, "grid-child");
+}
+
+/* Public API {{{2 */
+
+/**
+ * gtk_flow_box_child_new:
+ *
+ * Creates a new #GtkFlowBoxChild, to be used as a child
+ * of a #GtkFlowBox.
+ *
+ * Returns: a new #GtkFlowBoxChild
+ *
+ * Since: 3.12
+ */
+GtkWidget *
+gtk_flow_box_child_new (void)
+{
+  return g_object_new (GTK_TYPE_FLOW_BOX_CHILD, NULL);
+}
+
+/**
+ * gtk_flow_box_child_get_index:
+ * @child: a #GtkFlowBoxChild
+ *
+ * Gets the current index of the @child in its #GtkFlowBox container.
+ *
+ * Returns: the index of the @child, or -1 if the @child is not
+ *     in a flow box.
+ *
+ * Since: 3.12
+ */
+gint
+gtk_flow_box_child_get_index (GtkFlowBoxChild *child)
+{
+  GtkFlowBoxChildPrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_FLOW_BOX_CHILD (child), -1);
+
+  priv = CHILD_PRIV (child);
+
+  if (priv->iter != NULL)
+    return g_sequence_iter_get_position (priv->iter);
+
+  return -1;
+}
+
+/**
+ * gtk_flow_box_child_is_selected:
+ * @child: a #GtkFlowBoxChild
+ *
+ * Returns whether the @child is currently selected in its
+ * #GtkFlowBox container.
+ *
+ * Returns: %TRUE if @child is selected
+ *
+ * Since: 3.12
+ */
+gboolean
+gtk_flow_box_child_is_selected (GtkFlowBoxChild *child)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX_CHILD (child));
+
+  return CHILD_PRIV (child)->selected;
+}
+
+/**
+ * gtk_flow_box_child_changed:
+ * @child: a #GtkFlowBoxChild
+ *
+ * Marks @child as changed, causing any state that depends on this
+ * to be updated. This affects sorting and filtering.
+ *
+ * Note that calls to this method must be in sync with the data
+ * used for the sorting and filtering functions. For instance, if
+ * the list is mirroring some external data set, and *two* children
+ * changed in the external data set when you call
+ * gtk_flow_box_child_changed() on the first child, the sort function
+ * must only read the new data for the first of the two changed
+ * children, otherwise the resorting of the children will be wrong.
+ *
+ * This generally means that if you don't fully control the data
+ * model, you have to duplicate the data that affects the sorting
+ * and filtering functions into the widgets themselves. Another
+ * alternative is to call gtk_flow_box_invalidate_sort() on any
+ * model change, but that is more expensive.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_child_changed (GtkFlowBoxChild *child)
+{
+  GtkFlowBox *box;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX_CHILD (child));
+
+  box = gtk_flow_box_child_get_box (child);
+
+  if (box == NULL)
+    return;
+
+  gtk_flow_box_apply_sort (box, child);
+  gtk_flow_box_apply_filter (box, child);
+}
+
+/* GtkFlowBox  {{{1 */
+
+/* Constants {{{2 */
+
+#define DEFAULT_MAX_CHILDREN_PER_LINE 7
+#define RUBBERBAND_START_DISTANCE 32
+#define AUTOSCROLL_FAST_DISTANCE 32
+#define AUTOSCROLL_FACTOR 20
+#define AUTOSCROLL_FACTOR_FAST 10
+
+/* GObject boilerplate {{{2 */
+
+enum {
+  CHILD_ACTIVATED,
+  SELECTED_CHILDREN_CHANGED,
+  ACTIVATE_CURSOR_CHILD,
+  TOGGLE_CURSOR_CHILD,
+  MOVE_CURSOR,
+  SELECT_ALL,
+  UNSELECT_ALL,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+enum {
+  PROP_0,
+  PROP_ORIENTATION,
+  PROP_HOMOGENEOUS,
+  PROP_HALIGN_POLICY,
+  PROP_VALIGN_POLICY,
+  PROP_COLUMN_SPACING,
+  PROP_ROW_SPACING,
+  PROP_MIN_CHILDREN_PER_LINE,
+  PROP_MAX_CHILDREN_PER_LINE,
+  PROP_SELECTION_MODE,
+  PROP_ACTIVATE_ON_SINGLE_CLICK
+};
+
+typedef struct _GtkFlowBoxPrivate GtkFlowBoxPrivate;
+struct _GtkFlowBoxPrivate {
+  GtkOrientation    orientation;
+  gboolean          homogeneous;
+
+  guint             row_spacing;
+  guint             column_spacing;
+
+  GtkFlowBoxChild  *prelight_child;
+  GtkFlowBoxChild  *cursor_child;
+  GtkFlowBoxChild  *selected_child;
+
+  gboolean          active_child_active;
+  GtkFlowBoxChild  *active_child;
+
+  GtkSelectionMode  selection_mode;
+
+  GtkAdjustment    *hadjustment;
+  GtkAdjustment    *vadjustment;
+  gboolean          activate_on_single_click;
+
+  guint16           min_children_per_line;
+  guint16           max_children_per_line;
+  guint16           cur_children_per_line;
+
+  GSequence        *children;
+
+  GtkFlowBoxFilterFunc filter_func;
+  gpointer             filter_data;
+  GDestroyNotify       filter_destroy;
+
+  GtkFlowBoxSortFunc sort_func;
+  gpointer           sort_data;
+  GDestroyNotify     sort_destroy;
+
+  gboolean           track_motion;
+  gboolean           rubberband_select;
+  GtkFlowBoxChild   *rubberband_first;
+  GtkFlowBoxChild   *rubberband_last;
+  gint               button_down_x;
+  gint               button_down_y;
+  GdkDevice         *rubberband_device;
+
+  GtkScrollType      autoscroll_mode;
+  guint              autoscroll_id;
+};
+
+#define BOX_PRIV(box) ((GtkFlowBoxPrivate*)gtk_flow_box_get_instance_private ((GtkFlowBox*)(box)))
+
+G_DEFINE_TYPE_WITH_CODE (GtkFlowBox, gtk_flow_box, GTK_TYPE_CONTAINER,
+                         G_ADD_PRIVATE (GtkFlowBox)
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
+
+/* Internal API, utilities {{{2 */
+
+#define ORIENTATION_ALIGN(box)                              \
+  (BOX_PRIV(box)->orientation == GTK_ORIENTATION_HORIZONTAL \
+   ? gtk_widget_get_halign (GTK_WIDGET (box))               \
+   : gtk_widget_get_valign (GTK_WIDGET (box)))
+
+#define OPPOSING_ORIENTATION_ALIGN(box)                     \
+  (BOX_PRIV(box)->orientation == GTK_ORIENTATION_HORIZONTAL \
+   ? gtk_widget_get_valign (GTK_WIDGET (box))               \
+   : gtk_widget_get_halign (GTK_WIDGET (box)))
+
+/* Children are visible if they are shown by the app (visible)
+ * and not filtered out (child_visible) by the box
+ */
+static inline gboolean
+child_is_visible (GtkWidget *child)
+{
+  return gtk_widget_get_visible (child) &&
+         gtk_widget_get_child_visible (child);
+}
+
+static gint
+get_visible_children (GtkFlowBox *box)
+{
+  GSequenceIter *iter;
+  gint i = 0;
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+
+      child = g_sequence_get (iter);
+      if (child_is_visible (child))
+        i++;
+    }
+
+  return i;
+}
+
+static GtkFlowBoxChild *
+gtk_flow_box_find_child_at_pos (GtkFlowBox *box,
+                                gint        x,
+                                gint        y)
+{
+  GtkWidget *child;
+  GSequenceIter *iter;
+  GtkAllocation allocation;
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      child = g_sequence_get (iter);
+      if (!child_is_visible (child))
+        continue;
+      gtk_widget_get_allocation (child, &allocation);
+      if (x >= allocation.x && x < (allocation.x + allocation.width) &&
+          y >= allocation.y && y < (allocation.y + allocation.height))
+        return GTK_FLOW_BOX_CHILD (child);
+    }
+
+  return NULL;
+}
+
+static void
+gtk_flow_box_update_prelight (GtkFlowBox      *box,
+                              GtkFlowBoxChild *child)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  if (child != priv->prelight_child)
+    {
+      priv->prelight_child = child;
+      gtk_widget_queue_draw (GTK_WIDGET (box));
+    }
+}
+
+static void
+gtk_flow_box_update_active (GtkFlowBox      *box,
+                            GtkFlowBoxChild *child)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gboolean val;
+
+  val = priv->active_child == child;
+  if (priv->active_child != NULL &&
+      val != priv->active_child_active)
+    {
+      priv->active_child_active = val;
+      gtk_widget_queue_draw (GTK_WIDGET (box));
+    }
+}
+
+static void
+gtk_flow_box_apply_filter (GtkFlowBox      *box,
+                           GtkFlowBoxChild *child)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gboolean do_show;
+
+  do_show = TRUE;
+  if (priv->filter_func != NULL)
+    do_show = priv->filter_func (child, priv->filter_data);
+
+  gtk_widget_set_child_visible (GTK_WIDGET (child), do_show);
+}
+
+static void
+gtk_flow_box_apply_sort (GtkFlowBox      *box,
+                         GtkFlowBoxChild *child)
+{
+  if (BOX_PRIV (box)->sort_func != NULL)
+    {
+      g_sequence_sort_changed (CHILD_PRIV (child)->iter,
+                               (GCompareDataFunc)gtk_flow_box_sort, box);
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+    }
+}
+
+/* Selection utilities {{{3 */
+
+static gboolean
+gtk_flow_box_child_set_selected (GtkFlowBoxChild *child,
+                                 gboolean         selected)
+{
+  GtkFlowBox *box;
+
+  if (CHILD_PRIV (child)->selected != selected)
+    {
+      CHILD_PRIV (child)->selected = selected;
+      if (selected)
+        gtk_widget_set_state_flags (GTK_WIDGET (child),
+                                    GTK_STATE_FLAG_SELECTED, FALSE);
+      else
+        gtk_widget_unset_state_flags (GTK_WIDGET (child),
+                                      GTK_STATE_FLAG_SELECTED);
+
+      box = gtk_flow_box_child_get_box (child);
+      _gtk_flow_box_accessible_selection_changed (GTK_WIDGET (box));
+
+      gtk_widget_queue_draw (GTK_WIDGET (child));
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_unselect_all_internal (GtkFlowBox *box)
+{
+  GtkFlowBoxChild *child;
+  GSequenceIter *iter;
+  gboolean dirty = FALSE;
+
+  if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_NONE)
+    return FALSE;
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      child = g_sequence_get (iter);
+      dirty |= gtk_flow_box_child_set_selected (child, FALSE);
+    }
+
+  return dirty;
+}
+
+static void
+gtk_flow_box_unselect_child_info (GtkFlowBox      *box,
+                                  GtkFlowBoxChild *child)
+{
+  if (!CHILD_PRIV (child)->selected)
+    return;
+
+  if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_NONE)
+    return;
+  else if (BOX_PRIV (box)->selection_mode != GTK_SELECTION_MULTIPLE)
+    gtk_flow_box_unselect_all_internal (box);
+  else
+    gtk_flow_box_child_set_selected (child, FALSE);
+
+  g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+}
+
+static void
+gtk_flow_box_update_cursor (GtkFlowBox      *box,
+                            GtkFlowBoxChild *child)
+{
+  BOX_PRIV (box)->cursor_child = child;
+  gtk_widget_grab_focus (GTK_WIDGET (child));
+  gtk_widget_queue_draw (GTK_WIDGET (child));
+  _gtk_flow_box_accessible_update_cursor (GTK_WIDGET (box), GTK_WIDGET (child));
+}
+
+static void
+gtk_flow_box_select_child_info (GtkFlowBox      *box,
+                                GtkFlowBoxChild *child)
+{
+  if (CHILD_PRIV (child)->selected)
+    return;
+
+  if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_NONE)
+    return;
+  if (BOX_PRIV (box)->selection_mode != GTK_SELECTION_MULTIPLE)
+    gtk_flow_box_unselect_all_internal (box);
+
+  gtk_flow_box_child_set_selected (child, TRUE);
+  BOX_PRIV (box)->selected_child = child;
+
+  g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+
+  gtk_flow_box_update_cursor (box, child);
+}
+
+static void
+gtk_flow_box_select_all_between (GtkFlowBox      *box,
+                                 GtkFlowBoxChild *child1,
+                                 GtkFlowBoxChild *child2)
+{
+  GSequenceIter *iter, *iter1, *iter2;
+
+  if (child1)
+    iter1 = CHILD_PRIV (child1)->iter;
+  else
+    iter1 = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+
+  if (child2)
+    iter2 = CHILD_PRIV (child2)->iter;
+  else
+    iter2 = g_sequence_get_end_iter (BOX_PRIV (box)->children);
+
+  if (g_sequence_iter_compare (iter2, iter1) < 0)
+    {
+      iter = iter1;
+      iter1 = iter2;
+      iter2 = iter;
+    }
+
+  for (iter = iter1;
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+
+      child = g_sequence_get (iter);
+      if (child_is_visible (child))
+        gtk_flow_box_child_set_selected (GTK_FLOW_BOX_CHILD (child), TRUE);
+
+      if (g_sequence_iter_compare (iter, iter2) == 0)
+        break;
+    }
+}
+
+static void
+gtk_flow_box_update_selection (GtkFlowBox      *box,
+                               GtkFlowBoxChild *child,
+                               gboolean         modify,
+                               gboolean         extend)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  gtk_flow_box_update_cursor (box, child);
+
+  if (priv->selection_mode == GTK_SELECTION_NONE)
+    return;
+
+  if (priv->selection_mode == GTK_SELECTION_BROWSE)
+    {
+      gtk_flow_box_unselect_all_internal (box);
+      gtk_flow_box_child_set_selected (child, TRUE);
+      priv->selected_child = child;
+    }
+  else if (priv->selection_mode == GTK_SELECTION_SINGLE)
+    {
+      gboolean was_selected;
+
+      was_selected = CHILD_PRIV (child)->selected;
+      gtk_flow_box_unselect_all_internal (box);
+      gtk_flow_box_child_set_selected (child, modify ? !was_selected : TRUE);
+      priv->selected_child = CHILD_PRIV (child)->selected ? child : NULL;
+    }
+  else /* GTK_SELECTION_MULTIPLE */
+    {
+      if (extend)
+        {
+          gtk_flow_box_unselect_all_internal (box);
+          if (priv->selected_child == NULL)
+            {
+              gtk_flow_box_child_set_selected (child, TRUE);
+              priv->selected_child = child;
+            }
+          else
+            gtk_flow_box_select_all_between (box, priv->selected_child, child);
+        }
+      else
+        {
+          gtk_flow_box_child_set_selected (child, modify ? !CHILD_PRIV (child)->selected : TRUE);
+          priv->selected_child = child;
+        }
+    }
+
+  g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+}
+
+static void
+gtk_flow_box_select_and_activate (GtkFlowBox      *box,
+                                  GtkFlowBoxChild *child)
+{
+  if (child != NULL)
+    {
+      gtk_flow_box_select_child_info (box, child);
+      g_signal_emit (box, signals[CHILD_ACTIVATED], 0, child);
+    }
+}
+
+/* Focus utilities {{{3 */
+
+static GSequenceIter *
+gtk_flow_box_get_previous_focusable (GtkFlowBox    *box,
+                                     GSequenceIter *iter)
+{
+  GtkFlowBoxChild *child;
+
+  while (!g_sequence_iter_is_begin (iter))
+    {
+      iter = g_sequence_iter_prev (iter);
+      child = g_sequence_get (iter);
+      if (child_is_visible (GTK_WIDGET (child)) &&
+          gtk_widget_is_sensitive (GTK_WIDGET (child)))
+        return iter;
+    }
+
+  return NULL;
+}
+
+static GSequenceIter *
+gtk_flow_box_get_next_focusable (GtkFlowBox    *box,
+                                 GSequenceIter *iter)
+{
+  GtkFlowBoxChild *child;
+
+  while (TRUE)
+    {
+      iter = g_sequence_iter_next (iter);
+      if (g_sequence_iter_is_end (iter))
+        return iter;
+      child = g_sequence_get (iter);
+      if (child_is_visible (GTK_WIDGET (child)) &&
+          gtk_widget_is_sensitive (GTK_WIDGET (child)))
+        return iter;
+    }
+
+  return NULL;
+}
+
+static GSequenceIter *
+gtk_flow_box_get_first_focusable (GtkFlowBox *box)
+{
+  GSequenceIter *iter;
+  GtkFlowBoxChild *child;
+
+  iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+  child = g_sequence_get (iter);
+  if (child_is_visible (GTK_WIDGET (child)) &&
+      gtk_widget_is_sensitive (GTK_WIDGET (child)))
+    return iter;
+
+  return gtk_flow_box_get_next_focusable (box, iter);
+}
+
+static GSequenceIter *
+gtk_flow_box_get_last_focusable (GtkFlowBox *box)
+{
+  GSequenceIter *iter;
+
+  iter = g_sequence_get_end_iter (BOX_PRIV (box)->children);
+  return gtk_flow_box_get_previous_focusable (box, iter);
+}
+
+
+static GSequenceIter *
+gtk_flow_box_get_above_focusable (GtkFlowBox    *box,
+                                  GSequenceIter *iter)
+{
+  GtkFlowBoxChild *child = NULL;
+  gint i;
+
+  while (TRUE)
+    {
+      i = 0;
+      while (i < BOX_PRIV (box)->cur_children_per_line)
+        {
+          if (g_sequence_iter_is_begin (iter))
+            return NULL;
+          iter = g_sequence_iter_prev (iter);
+          child = g_sequence_get (iter);
+          if (child_is_visible (GTK_WIDGET (child)))
+            i++;
+        }
+      if (child && gtk_widget_get_sensitive (GTK_WIDGET (child)))
+        return iter;
+    }
+
+  return NULL;
+}
+
+static GSequenceIter *
+gtk_flow_box_get_below_focusable (GtkFlowBox    *box,
+                                  GSequenceIter *iter)
+{
+  GtkFlowBoxChild *child = NULL;
+  gint i;
+
+  while (TRUE)
+    {
+      i = 0;
+      while (i < BOX_PRIV (box)->cur_children_per_line)
+        {
+          iter = g_sequence_iter_next (iter);
+          if (g_sequence_iter_is_end (iter))
+            return iter;
+          child = g_sequence_get (iter);
+          if (child_is_visible (GTK_WIDGET (child)))
+            i++;
+        }
+      if (child && gtk_widget_get_sensitive (GTK_WIDGET (child)))
+        return iter;
+    }
+
+  return NULL;
+}
+
+/* GtkWidget implementation {{{2 */
+
+/* Size allocation {{{3 */
+
+/* Used in columned modes where all items share at least their
+ * equal widths or heights
+ */
+static void
+get_max_item_size (GtkFlowBox     *box,
+                   GtkOrientation  orientation,
+                   gint           *min_size,
+                   gint           *nat_size)
+{
+  GSequenceIter *iter;
+  gint max_min_size = 0;
+  gint max_nat_size = 0;
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+      gint child_min, child_nat;
+
+      child = g_sequence_get (iter);
+
+      if (!child_is_visible (child))
+        continue;
+
+      if (orientation == GTK_ORIENTATION_HORIZONTAL)
+        gtk_widget_get_preferred_width (child, &child_min, &child_nat);
+      else
+        gtk_widget_get_preferred_height (child, &child_min, &child_nat);
+
+      max_min_size = MAX (max_min_size, child_min);
+      max_nat_size = MAX (max_nat_size, child_nat);
+    }
+
+  if (min_size)
+    *min_size = max_min_size;
+
+  if (nat_size)
+    *nat_size = max_nat_size;
+}
+
+
+/* Gets the largest minimum/natural size for a given size (used to get
+ * the largest item heights for a fixed item width and the opposite)
+ */
+static void
+get_largest_size_for_opposing_orientation (GtkFlowBox     *box,
+                                           GtkOrientation  orientation,
+                                           gint            item_size,
+                                           gint           *min_item_size,
+                                           gint           *nat_item_size)
+{
+  GSequenceIter *iter;
+  gint max_min_size = 0;
+  gint max_nat_size = 0;
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+      gint       child_min, child_nat;
+
+      child = g_sequence_get (iter);
+
+      if (!child_is_visible (child))
+        continue;
+
+      if (orientation == GTK_ORIENTATION_HORIZONTAL)
+        gtk_widget_get_preferred_height_for_width (child,
+                                                   item_size,
+                                                   &child_min, &child_nat);
+      else
+        gtk_widget_get_preferred_width_for_height (child,
+                                                   item_size,
+                                                   &child_min, &child_nat);
+
+      max_min_size = MAX (max_min_size, child_min);
+      max_nat_size = MAX (max_nat_size, child_nat);
+    }
+
+  if (min_item_size)
+    *min_item_size = max_min_size;
+
+  if (nat_item_size)
+    *nat_item_size = max_nat_size;
+}
+
+/* Gets the largest minimum/natural size on a single line for a given size
+ * (used to get the largest line heights for a fixed item width and the opposite
+ * while iterating over a list of children, note the new index is returned)
+ */
+static GSequenceIter *
+get_largest_size_for_line_in_opposing_orientation (GtkFlowBox       *box,
+                                                   GtkOrientation    orientation,
+                                                   GSequenceIter    *cursor,
+                                                   gint              line_length,
+                                                   GtkRequestedSize *item_sizes,
+                                                   gint              extra_pixels,
+                                                   gint             *min_item_size,
+                                                   gint             *nat_item_size)
+{
+  GSequenceIter *iter;
+  gint max_min_size = 0;
+  gint max_nat_size = 0;
+  gint i;
+
+  i = 0;
+  for (iter = cursor;
+       !g_sequence_iter_is_end (iter) && i < line_length;
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+      gint child_min, child_nat, this_item_size;
+
+      child = g_sequence_get (iter);
+
+      if (!child_is_visible (child))
+        continue;
+
+      /* Distribute the extra pixels to the first children in the line
+       * (could be fancier and spread them out more evenly) */
+      this_item_size = item_sizes[i].minimum_size;
+      if (extra_pixels > 0 && ORIENTATION_ALIGN (box) == GTK_ALIGN_FILL)
+        {
+          this_item_size++;
+          extra_pixels--;
+        }
+
+      if (orientation == GTK_ORIENTATION_HORIZONTAL)
+        gtk_widget_get_preferred_height_for_width (child,
+                                                   this_item_size,
+                                                   &child_min, &child_nat);
+      else
+        gtk_widget_get_preferred_width_for_height (child,
+                                                   this_item_size,
+                                                   &child_min, &child_nat);
+
+      max_min_size = MAX (max_min_size, child_min);
+      max_nat_size = MAX (max_nat_size, child_nat);
+
+      i++;
+    }
+
+  if (min_item_size)
+    *min_item_size = max_min_size;
+
+  if (nat_item_size)
+    *nat_item_size = max_nat_size;
+
+  /* Return next item in the list */
+  return iter;
+}
+
+/* fit_aligned_item_requests() helper */
+static gint
+gather_aligned_item_requests (GtkFlowBox       *box,
+                              GtkOrientation    orientation,
+                              gint              line_length,
+                              gint              item_spacing,
+                              gint              n_children,
+                              GtkRequestedSize *item_sizes)
+{
+  GSequenceIter *iter;
+  gint i;
+  gint extra_items, natural_line_size = 0;
+
+  extra_items = n_children % line_length;
+
+  i = 0;
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+      GtkAlign item_align;
+      gint child_min, child_nat;
+      gint position;
+
+      child = g_sequence_get (iter);
+
+      if (!child_is_visible (child))
+        continue;
+
+      if (orientation == GTK_ORIENTATION_HORIZONTAL)
+        gtk_widget_get_preferred_width (child,
+                                        &child_min, &child_nat);
+      else
+        gtk_widget_get_preferred_height (child,
+                                         &child_min, &child_nat);
+
+      /* Get the index and push it over for the last line when spreading to the end */
+      position = i % line_length;
+
+      item_align = ORIENTATION_ALIGN (box);
+      if (item_align == GTK_ALIGN_END && i >= n_children - extra_items)
+        position += line_length - extra_items;
+
+      /* Round up the size of every column/row */
+      item_sizes[position].minimum_size = MAX (item_sizes[position].minimum_size, child_min);
+      item_sizes[position].natural_size = MAX (item_sizes[position].natural_size, child_nat);
+
+      i++;
+    }
+
+  for (i = 0; i < line_length; i++)
+    natural_line_size += item_sizes[i].natural_size;
+
+  natural_line_size += (line_length - 1) * item_spacing;
+
+  return natural_line_size;
+}
+
+static GtkRequestedSize *
+fit_aligned_item_requests (GtkFlowBox     *box,
+                           GtkOrientation  orientation,
+                           gint            avail_size,
+                           gint            item_spacing,
+                           gint           *line_length, /* in-out */
+                           gint            items_per_line,
+                           gint            n_children)
+{
+  GtkRequestedSize *sizes, *try_sizes;
+  gint try_line_size, try_length;
+
+  sizes = g_new0 (GtkRequestedSize, *line_length);
+
+  /* get the sizes for the initial guess */
+  try_line_size = gather_aligned_item_requests (box,
+                                                orientation,
+                                                *line_length,
+                                                item_spacing,
+                                                n_children,
+                                                sizes);
+
+  /* Try columnizing the whole thing and adding an item to the end of
+   * the line; try to fit as many columns into the available size as
+   * possible
+   */
+  for (try_length = *line_length + 1; try_line_size < avail_size; try_length++)
+    {
+      try_sizes = g_new0 (GtkRequestedSize, try_length);
+      try_line_size = gather_aligned_item_requests (box,
+                                                    orientation,
+                                                    try_length,
+                                                    item_spacing,
+                                                    n_children,
+                                                    try_sizes);
+
+      if (try_line_size <= avail_size &&
+          items_per_line >= try_length)
+        {
+          *line_length = try_length;
+
+          g_free (sizes);
+          sizes = try_sizes;
+        }
+      else
+        {
+          /* oops, this one failed; stick to the last size that fit and then return */
+          g_free (try_sizes);
+          break;
+        }
+    }
+
+  return sizes;
+}
+
+typedef struct {
+  GArray *requested;
+  gint    extra_pixels;
+} AllocatedLine;
+
+static gint
+get_offset_pixels (GtkAlign align,
+                   gint     pixels)
+{
+  gint offset;
+
+  switch (align) {
+  case GTK_ALIGN_START:
+  case GTK_ALIGN_FILL:
+    offset = 0;
+    break;
+  case GTK_ALIGN_CENTER:
+    offset = pixels / 2;
+    break;
+  case GTK_ALIGN_END:
+    offset = pixels;
+    break;
+  default:
+    g_assert_not_reached ();
+    break;
+  }
+
+  return offset;
+}
+
+static void
+gtk_flow_box_size_allocate (GtkWidget     *widget,
+                            GtkAllocation *allocation)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate  *priv = BOX_PRIV (box);
+  GtkAllocation child_allocation;
+  gint avail_size, avail_other_size, min_items, item_spacing, line_spacing;
+  GtkAlign item_align;
+  GtkAlign line_align;
+  GdkWindow *window;
+  GtkRequestedSize *line_sizes = NULL;
+  GtkRequestedSize *item_sizes = NULL;
+  gint min_item_size, nat_item_size;
+  gint line_length;
+  gint item_size = 0;
+  gint line_size = 0, min_fixed_line_size = 0, nat_fixed_line_size = 0;
+  gint line_offset, item_offset, n_children, n_lines, line_count;
+  gint extra_pixels = 0, extra_per_item = 0, extra_extra = 0;
+  gint extra_line_pixels = 0, extra_per_line = 0, extra_line_extra = 0;
+  gint i, this_line_size;
+  GSequenceIter *iter;
+
+  child_allocation.x = 0;
+  child_allocation.y = 0;
+  child_allocation.width = 0;
+  child_allocation.height = 0;
+
+  gtk_widget_set_allocation (widget, allocation);
+  window = gtk_widget_get_window (widget);
+  if (window != NULL)
+    gdk_window_move_resize (window,
+                            allocation->x, allocation->y,
+                            allocation->width, allocation->height);
+
+  child_allocation.x = 0;
+  child_allocation.y = 0;
+  child_allocation.width = allocation->width;
+
+  min_items = MAX (1, priv->min_children_per_line);
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      avail_size = allocation->width;
+      avail_other_size = allocation->height;
+      item_spacing = priv->column_spacing; line_spacing = priv->row_spacing;
+    }
+  else /* GTK_ORIENTATION_VERTICAL */
+    {
+      avail_size = allocation->height;
+      avail_other_size = allocation->width;
+      item_spacing = priv->row_spacing;
+      line_spacing = priv->column_spacing;
+    }
+
+  item_align = ORIENTATION_ALIGN (box);
+  line_align = OPPOSING_ORIENTATION_ALIGN (box);
+
+  /* Get how many lines we'll be needing to flow */
+  n_children = get_visible_children (box);
+  if (n_children <= 0)
+    return;
+
+  /*
+   * Deal with ALIGNED/HOMOGENEOUS modes first, start with
+   * initial guesses at item/line sizes
+   */
+  get_max_item_size (box, priv->orientation, &min_item_size, &nat_item_size);
+  if (nat_item_size <= 0)
+    return;
+
+  /* By default flow at the natural item width */
+  line_length = avail_size / (nat_item_size + item_spacing);
+
+  /* After the above aproximation, check if we cant fit one more on the line */
+  if (line_length * item_spacing + (line_length + 1) * nat_item_size <= avail_size)
+    line_length++;
+
+  /* Its possible we were allocated just less than the natural width of the
+   * minimum item flow length */
+  line_length = MAX (min_items, line_length);
+  line_length = MIN (line_length, priv->max_children_per_line);
+
+  /* Here we just use the largest height-for-width and use that for the height
+   * of all lines */
+  if (priv->homogeneous)
+    {
+      n_lines = n_children / line_length;
+      if ((n_children % line_length) > 0)
+        n_lines++;
+
+      n_lines = MAX (n_lines, 1);
+
+      /* Now we need the real item allocation size */
+      item_size = (avail_size - (line_length - 1) * item_spacing) / line_length;
+
+      /* Cut out the expand space if we're not distributing any */
+      if (item_align != GTK_ALIGN_FILL)
+        item_size = MIN (item_size, nat_item_size);
+
+      get_largest_size_for_opposing_orientation (box,
+                                                 priv->orientation,
+                                                 item_size,
+                                                 &min_fixed_line_size,
+                                                 &nat_fixed_line_size);
+
+      /* resolve a fixed 'line_size' */
+      line_size = (avail_other_size - (n_lines - 1) * line_spacing) / n_lines;
+
+      if (line_align != GTK_ALIGN_FILL)
+        line_size = MIN (line_size, nat_fixed_line_size);
+
+      /* Get the real extra pixels incase of GTK_ALIGN_START lines */
+      extra_pixels      = avail_size       - (line_length - 1) * item_spacing - item_size * line_length;
+      extra_line_pixels = avail_other_size - (n_lines - 1)     * line_spacing - line_size * n_lines;
+    }
+  else
+    {
+      gboolean first_line = TRUE;
+
+      /* Find the amount of columns that can fit aligned into the available space
+       * and collect their requests.
+       */
+      item_sizes = fit_aligned_item_requests (box,
+                                              priv->orientation,
+                                              avail_size,
+                                              item_spacing,
+                                              &line_length,
+                                              priv->max_children_per_line,
+                                              n_children);
+
+      /* Calculate the number of lines after determining the final line_length */
+      n_lines = n_children / line_length;
+      if ((n_children % line_length) > 0)
+        n_lines++;
+
+      n_lines = MAX (n_lines, 1);
+      line_sizes = g_new0 (GtkRequestedSize, n_lines);
+
+      /* Get the available remaining size */
+      avail_size -= (line_length - 1) * item_spacing;
+      for (i = 0; i < line_length; i++)
+        avail_size -= item_sizes[i].minimum_size;
+
+      /* Perform a natural allocation on the columnized items and get the remaining pixels */
+      if (avail_size > 0)
+        extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
+
+      /* Now that we have the size of each column of items find the size of each individual
+       * line based on the aligned item sizes.
+       */
+
+      for (i = 0, iter = g_sequence_get_begin_iter (priv->children);
+           !g_sequence_iter_is_end (iter) && i < n_lines;
+           i++)
+        {
+          iter = get_largest_size_for_line_in_opposing_orientation (box,
+                                                                    priv->orientation,
+                                                                    iter,
+                                                                    line_length,
+                                                                    item_sizes,
+                                                                    extra_pixels,
+                                                                    &line_sizes[i].minimum_size,
+                                                                    &line_sizes[i].natural_size);
+
+
+          /* Its possible a line is made of completely invisible children */
+          if (line_sizes[i].natural_size > 0)
+            {
+              if (first_line)
+                first_line = FALSE;
+              else
+                avail_other_size -= line_spacing;
+
+              avail_other_size -= line_sizes[i].minimum_size;
+
+              line_sizes[i].data = GINT_TO_POINTER (i);
+            }
+        }
+
+      /* Distribute space among lines naturally */
+      if (avail_other_size > 0)
+        extra_line_pixels = gtk_distribute_natural_allocation (avail_other_size, n_lines, line_sizes);
+    }
+
+  /*
+   * Initial sizes of items/lines guessed at this point,
+   * go on to distribute expand space if needed.
+   */
+
+  priv->cur_children_per_line = line_length;
+
+  /* FIXME: This portion needs to consider which columns
+   * and rows asked for expand space and distribute those
+   * accordingly for the case of ALIGNED allocation.
+   *
+   * If at least one child in a column/row asked for expand;
+   * we should make that row/column expand entirely.
+   */
+
+  /* Calculate expand space per item */
+  if (item_align == GTK_ALIGN_FILL)
+    {
+      extra_per_item = extra_pixels / line_length;
+      extra_extra    = extra_pixels % line_length;
+    }
+
+  /* Calculate expand space per line */
+  if (line_align == GTK_ALIGN_FILL)
+    {
+      extra_per_line   = extra_line_pixels / n_lines;
+      extra_line_extra = extra_line_pixels % n_lines;
+    }
+
+  /*
+   * Prepare item/line initial offsets and jump into the
+   * real allocation loop.
+   */
+  line_offset = item_offset = 0;
+
+  /* prepend extra space to item_offset/line_offset for SPREAD_END */
+  item_offset += get_offset_pixels (item_align, extra_pixels);
+  line_offset += get_offset_pixels (line_align, extra_line_pixels);
+
+  /* Get the allocation size for the first line */
+  if (priv->homogeneous)
+    this_line_size = line_size;
+  else
+    {
+      this_line_size = line_sizes[0].minimum_size;
+
+      if (line_align == GTK_ALIGN_FILL)
+        {
+          this_line_size += extra_per_line;
+
+          if (extra_line_extra > 0)
+            this_line_size++;
+        }
+    }
+
+  i = 0;
+  line_count = 0;
+  for (iter = g_sequence_get_begin_iter (priv->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+      gint position;
+      gint this_item_size;
+
+      child = g_sequence_get (iter);
+
+      if (!child_is_visible (child))
+        continue;
+
+      /* Get item position */
+      position = i % line_length;
+
+      /* adjust the line_offset/count at the beginning of each new line */
+      if (i > 0 && position == 0)
+        {
+          /* Push the line_offset */
+          line_offset += this_line_size + line_spacing;
+
+          line_count++;
+
+          /* Get the new line size */
+          if (priv->homogeneous)
+            this_line_size = line_size;
+          else
+            {
+              this_line_size = line_sizes[line_count].minimum_size;
+
+              if (line_align == GTK_ALIGN_FILL)
+                {
+                  this_line_size += extra_per_line;
+
+                  if (line_count < extra_line_extra)
+                    this_line_size++;
+                }
+            }
+
+          item_offset = 0;
+
+          if (item_align == GTK_ALIGN_CENTER)
+            {
+              item_offset += get_offset_pixels (item_align, extra_pixels);
+            }
+          else if (item_align == GTK_ALIGN_END)
+            {
+              item_offset += get_offset_pixels (item_align, extra_pixels);
+
+              /* If we're on the last line, prepend the space for
+               * any leading items */
+              if (line_count == n_lines -1)
+                {
+                  gint extra_items = n_children % line_length;
+
+                  if (priv->homogeneous)
+                    {
+                      item_offset += item_size * (line_length - extra_items);
+                      item_offset += item_spacing * (line_length - extra_items);
+                    }
+                  else
+                    {
+                      gint j;
+
+                      for (j = 0; j < (line_length - extra_items); j++)
+                        {
+                          item_offset += item_sizes[j].minimum_size;
+                          item_offset += item_spacing;
+                        }
+                    }
+                }
+            }
+        }
+
+      /* Push the index along for the last line when spreading to the end */
+      if (item_align == GTK_ALIGN_END && line_count == n_lines -1)
+        {
+          gint extra_items = n_children % line_length;
+
+          position += line_length - extra_items;
+        }
+
+      if (priv->homogeneous)
+        this_item_size = item_size;
+      else
+        this_item_size = item_sizes[position].minimum_size;
+
+      if (item_align == GTK_ALIGN_FILL)
+        {
+          this_item_size += extra_per_item;
+
+          if (position < extra_extra)
+            this_item_size++;
+        }
+
+      /* Do the actual allocation */
+      if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+        {
+          child_allocation.x = item_offset;
+          child_allocation.y = line_offset;
+          child_allocation.width = this_item_size;
+          child_allocation.height = this_line_size;
+        }
+      else /* GTK_ORIENTATION_VERTICAL */
+        {
+          child_allocation.x = line_offset;
+          child_allocation.y = item_offset;
+          child_allocation.width = this_line_size;
+          child_allocation.height = this_item_size;
+        }
+
+      if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+        child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) - 
child_allocation.width;
+      gtk_widget_size_allocate (child, &child_allocation);
+
+      item_offset += this_item_size;
+      item_offset += item_spacing;
+
+      i++;
+    }
+
+  g_free (item_sizes);
+  g_free (line_sizes);
+}
+
+static GtkSizeRequestMode
+gtk_flow_box_get_request_mode (GtkWidget *widget)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+
+  return (BOX_PRIV (box)->orientation == GTK_ORIENTATION_HORIZONTAL) ?
+    GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH : GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT;
+}
+
+/* Gets the largest minimum and natural length of
+ * 'line_length' consecutive items when aligned into rows/columns */
+static void
+get_largest_aligned_line_length (GtkFlowBox     *box,
+                                 GtkOrientation  orientation,
+                                 gint            line_length,
+                                 gint           *min_size,
+                                 gint           *nat_size)
+{
+  GSequenceIter *iter;
+  gint max_min_size = 0;
+  gint max_nat_size = 0;
+  gint spacing, i;
+  GtkRequestedSize *aligned_item_sizes;
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    spacing = BOX_PRIV (box)->column_spacing;
+  else
+    spacing = BOX_PRIV (box)->row_spacing;
+
+  aligned_item_sizes = g_new0 (GtkRequestedSize, line_length);
+
+  /* Get the largest sizes of each index in the line.
+   */
+  i = 0;
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      GtkWidget *child;
+      gint child_min, child_nat;
+
+      child = g_sequence_get (iter);
+      if (!child_is_visible (child))
+        continue;
+
+      if (orientation == GTK_ORIENTATION_HORIZONTAL)
+        gtk_widget_get_preferred_width (child,
+                                        &child_min, &child_nat);
+      else /* GTK_ORIENTATION_VERTICAL */
+        gtk_widget_get_preferred_height (child,
+                                         &child_min, &child_nat);
+
+      aligned_item_sizes[i % line_length].minimum_size =
+        MAX (aligned_item_sizes[i % line_length].minimum_size, child_min);
+
+      aligned_item_sizes[i % line_length].natural_size =
+        MAX (aligned_item_sizes[i % line_length].natural_size, child_nat);
+
+      i++;
+    }
+
+  /* Add up the largest indexes */
+  for (i = 0; i < line_length; i++)
+    {
+      max_min_size += aligned_item_sizes[i].minimum_size;
+      max_nat_size += aligned_item_sizes[i].natural_size;
+    }
+
+  g_free (aligned_item_sizes);
+
+  max_min_size += (line_length - 1) * spacing;
+  max_nat_size += (line_length - 1) * spacing;
+
+  if (min_size)
+    *min_size = max_min_size;
+
+  if (nat_size)
+    *nat_size = max_nat_size;
+}
+
+
+static void
+gtk_flow_box_get_preferred_width (GtkWidget *widget,
+                                  gint      *minimum_size,
+                                  gint      *natural_size)
+{
+  GtkFlowBox *box  = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gint min_item_width, nat_item_width;
+  gint min_items, nat_items;
+  gint min_width, nat_width;
+
+  min_items = MAX (1, priv->min_children_per_line);
+  nat_items = MAX (min_items, priv->max_children_per_line);
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      min_width = nat_width = 0;
+
+      if (!priv->homogeneous)
+        {
+          /* When not homogeneous; horizontally oriented boxes
+           * need enough width for the widest row */
+          if (min_items == 1)
+            {
+              get_max_item_size (box,
+                                 GTK_ORIENTATION_HORIZONTAL,
+                                 &min_item_width,
+                                 &nat_item_width);
+
+              min_width += min_item_width;
+              nat_width += nat_item_width;
+            }
+          else
+            {
+              gint min_line_length, nat_line_length;
+
+              get_largest_aligned_line_length (box,
+                                               GTK_ORIENTATION_HORIZONTAL,
+                                               min_items,
+                                               &min_line_length,
+                                               &nat_line_length);
+
+              if (nat_items > min_items)
+                get_largest_aligned_line_length (box,
+                                                 GTK_ORIENTATION_HORIZONTAL,
+                                                 nat_items,
+                                                 NULL,
+                                                 &nat_line_length);
+
+              min_width += min_line_length;
+              nat_width += nat_line_length;
+            }
+        }
+      else /* In homogeneous mode; horizontally oriented boxs
+            * give the same width to all children */
+        {
+          get_max_item_size (box, GTK_ORIENTATION_HORIZONTAL,
+                             &min_item_width, &nat_item_width);
+
+          min_width += min_item_width * min_items;
+          min_width += (min_items -1) * priv->column_spacing;
+
+          nat_width += nat_item_width * nat_items;
+          nat_width += (nat_items -1) * priv->column_spacing;
+        }
+    }
+  else /* GTK_ORIENTATION_VERTICAL */
+    {
+      /* Return the width for the minimum height */
+      gint min_height;
+
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, NULL);
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_width_for_height (widget,
+                                                                     min_height,
+                                                                     &min_width,
+                                                                     &nat_width);
+
+    }
+
+  if (minimum_size)
+    *minimum_size = min_width;
+
+  if (natural_size)
+    *natural_size = nat_width;
+}
+
+static void
+gtk_flow_box_get_preferred_height (GtkWidget *widget,
+                                   gint      *minimum_size,
+                                   gint      *natural_size)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gint min_item_height, nat_item_height;
+  gint min_items, nat_items;
+  gint min_height, nat_height;
+
+  min_items = MAX (1, priv->min_children_per_line);
+  nat_items = MAX (min_items, priv->max_children_per_line);
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      /* Return the height for the minimum width */
+      gint min_width;
+
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget,
+                                                                     min_width,
+                                                                     &min_height,
+                                                                     &nat_height);
+    }
+  else /* GTK_ORIENTATION_VERTICAL */
+    {
+      min_height = nat_height = 0;
+
+      if (! priv->homogeneous)
+        {
+          /* When not homogeneous; vertically oriented boxes
+           * need enough height for the tallest column */
+          if (min_items == 1)
+            {
+              get_max_item_size (box, GTK_ORIENTATION_VERTICAL,
+                                 &min_item_height, &nat_item_height);
+
+              min_height += min_item_height;
+              nat_height += nat_item_height;
+            }
+          else
+            {
+              gint min_line_length, nat_line_length;
+
+              get_largest_aligned_line_length (box,
+                                               GTK_ORIENTATION_VERTICAL,
+                                               min_items,
+                                               &min_line_length,
+                                               &nat_line_length);
+
+              if (nat_items > min_items)
+                get_largest_aligned_line_length (box,
+                                                 GTK_ORIENTATION_VERTICAL,
+                                                 nat_items,
+                                                 NULL,
+                                                 &nat_line_length);
+
+              min_height += min_line_length;
+              nat_height += nat_line_length;
+            }
+
+        }
+      else
+        {
+          /* In homogeneous mode; vertically oriented boxes
+           * give the same height to all children
+           */
+          get_max_item_size (box,
+                             GTK_ORIENTATION_VERTICAL,
+                             &min_item_height,
+                             &nat_item_height);
+
+          min_height += min_item_height * min_items;
+          min_height += (min_items -1) * priv->row_spacing;
+
+          nat_height += nat_item_height * nat_items;
+          nat_height += (nat_items -1) * priv->row_spacing;
+        }
+    }
+
+  if (minimum_size)
+    *minimum_size = min_height;
+
+  if (natural_size)
+    *natural_size = nat_height;
+}
+
+static void
+gtk_flow_box_get_preferred_height_for_width (GtkWidget *widget,
+                                             gint       width,
+                                             gint      *minimum_height,
+                                             gint      *natural_height)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gint min_item_width, nat_item_width;
+  gint min_items;
+  gint min_height, nat_height;
+  gint avail_size, n_children;
+
+  min_items = MAX (1, priv->min_children_per_line);
+
+  min_height = 0;
+  nat_height = 0;
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      gint min_width;
+      gint line_length;
+      gint item_size, extra_pixels;
+
+      n_children = get_visible_children (box);
+      if (n_children <= 0)
+        goto out;
+
+      /* Make sure its no smaller than the minimum */
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);
+
+      avail_size = MAX (width, min_width);
+      if (avail_size <= 0)
+        goto out;
+
+      get_max_item_size (box, GTK_ORIENTATION_HORIZONTAL, &min_item_width, &nat_item_width);
+      if (nat_item_width <= 0)
+        goto out;
+
+      /* By default flow at the natural item width */
+      line_length = avail_size / (nat_item_width + priv->column_spacing);
+
+      /* After the above aproximation, check if we cant fit one more on the line */
+      if (line_length * priv->column_spacing + (line_length + 1) * nat_item_width <= avail_size)
+        line_length++;
+
+      /* Its possible we were allocated just less than the natural width of the
+       * minimum item flow length
+       */
+      line_length = MAX (min_items, line_length);
+      line_length = MIN (line_length, priv->max_children_per_line);
+
+      /* Now we need the real item allocation size */
+      item_size = (avail_size - (line_length - 1) * priv->column_spacing) / line_length;
+
+      /* Cut out the expand space if we're not distributing any */
+      if (gtk_widget_get_halign (widget) != GTK_ALIGN_FILL)
+        {
+          item_size    = MIN (item_size, nat_item_width);
+          extra_pixels = 0;
+        }
+      else
+        /* Collect the extra pixels for expand children */
+        extra_pixels = (avail_size - (line_length - 1) * priv->column_spacing) % line_length;
+
+      if (priv->homogeneous)
+        {
+          gint min_item_height, nat_item_height;
+          gint lines;
+
+          /* Here we just use the largest height-for-width and
+           * add up the size accordingly
+           */
+          get_largest_size_for_opposing_orientation (box,
+                                                     GTK_ORIENTATION_HORIZONTAL,
+                                                     item_size,
+                                                     &min_item_height,
+                                                     &nat_item_height);
+
+          /* Round up how many lines we need to allocate for */
+          lines = n_children / line_length;
+          if ((n_children % line_length) > 0)
+            lines++;
+
+          min_height = min_item_height * lines;
+          nat_height = nat_item_height * lines;
+
+          min_height += (lines - 1) * priv->row_spacing;
+          nat_height += (lines - 1) * priv->row_spacing;
+        }
+      else
+        {
+          gint min_line_height, nat_line_height, i;
+          gboolean first_line = TRUE;
+          GtkRequestedSize *item_sizes;
+          GSequenceIter *iter;
+
+          /* First get the size each set of items take to span the line
+           * when aligning the items above and below after flowping.
+           */
+          item_sizes = fit_aligned_item_requests (box,
+                                                  priv->orientation,
+                                                  avail_size,
+                                                  priv->column_spacing,
+                                                  &line_length,
+                                                  priv->max_children_per_line,
+                                                  n_children);
+
+          /* Get the available remaining size */
+          avail_size -= (line_length - 1) * priv->column_spacing;
+          for (i = 0; i < line_length; i++)
+            avail_size -= item_sizes[i].minimum_size;
+
+          if (avail_size > 0)
+            extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
+
+          for (iter = g_sequence_get_begin_iter (priv->children);
+               !g_sequence_iter_is_end (iter);)
+            {
+              iter = get_largest_size_for_line_in_opposing_orientation (box,
+                                                                        GTK_ORIENTATION_HORIZONTAL,
+                                                                        iter,
+                                                                        line_length,
+                                                                        item_sizes,
+                                                                        extra_pixels,
+                                                                        &min_line_height,
+                                                                        &nat_line_height);
+              /* Its possible the line only had invisible widgets */
+              if (nat_line_height > 0)
+                {
+                  if (first_line)
+                    first_line = FALSE;
+                  else
+                    {
+                      min_height += priv->row_spacing;
+                      nat_height += priv->row_spacing;
+                    }
+
+                  min_height += min_line_height;
+                  nat_height += nat_line_height;
+                }
+            }
+
+          g_free (item_sizes);
+        }
+    }
+  else /* GTK_ORIENTATION_VERTICAL */
+    {
+      /* Return the minimum height */
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, &nat_height);
+    }
+
+ out:
+
+  if (minimum_height)
+    *minimum_height = min_height;
+
+  if (natural_height)
+    *natural_height = nat_height;
+}
+
+static void
+gtk_flow_box_get_preferred_width_for_height (GtkWidget *widget,
+                                             gint       height,
+                                             gint      *minimum_width,
+                                             gint      *natural_width)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gint min_item_height, nat_item_height;
+  gint min_items;
+  gint min_width, nat_width;
+  gint avail_size, n_children;
+
+  min_items = MAX (1, priv->min_children_per_line);
+
+  min_width = 0;
+  nat_width = 0;
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      /* Return the minimum width */
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, &nat_width);
+    }
+  else /* GTK_ORIENTATION_VERTICAL */
+    {
+      gint min_height;
+      gint line_length;
+      gint item_size, extra_pixels;
+
+      n_children = get_visible_children (box);
+      if (n_children <= 0)
+        goto out;
+
+      /* Make sure its no smaller than the minimum */
+      GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, &min_height, NULL);
+
+      avail_size = MAX (height, min_height);
+      if (avail_size <= 0)
+        goto out;
+
+      get_max_item_size (box, GTK_ORIENTATION_VERTICAL, &min_item_height, &nat_item_height);
+
+      /* By default flow at the natural item width */
+      line_length = avail_size / (nat_item_height + priv->row_spacing);
+
+      /* After the above aproximation, check if we cant fit one more on the line */
+      if (line_length * priv->row_spacing + (line_length + 1) * nat_item_height <= avail_size)
+        line_length++;
+
+      /* Its possible we were allocated just less than the natural width of the
+       * minimum item flow length
+       */
+      line_length = MAX (min_items, line_length);
+      line_length = MIN (line_length, priv->max_children_per_line);
+
+      /* Now we need the real item allocation size */
+      item_size = (avail_size - (line_length - 1) * priv->row_spacing) / line_length;
+
+      /* Cut out the expand space if we're not distributing any */
+      if (gtk_widget_get_valign (widget) != GTK_ALIGN_FILL)
+        {
+          item_size = MIN (item_size, nat_item_height);
+          extra_pixels = 0;
+        }
+      else
+        /* Collect the extra pixels for expand children */
+        extra_pixels = (avail_size - (line_length - 1) * priv->row_spacing) % line_length;
+
+      if (priv->homogeneous)
+        {
+          gint min_item_width, nat_item_width;
+          gint lines;
+
+          /* Here we just use the largest height-for-width and
+           * add up the size accordingly
+           */
+          get_largest_size_for_opposing_orientation (box,
+                                                     GTK_ORIENTATION_VERTICAL,
+                                                     item_size,
+                                                     &min_item_width,
+                                                     &nat_item_width);
+
+          /* Round up how many lines we need to allocate for */
+          n_children = get_visible_children (box);
+          lines = n_children / line_length;
+          if ((n_children % line_length) > 0)
+            lines++;
+
+          min_width = min_item_width * lines;
+          nat_width = nat_item_width * lines;
+
+          min_width += (lines - 1) * priv->column_spacing;
+          nat_width += (lines - 1) * priv->column_spacing;
+        }
+      else
+        {
+          gint min_line_width, nat_line_width, i;
+          gboolean first_line = TRUE;
+          GtkRequestedSize *item_sizes;
+          GSequenceIter *iter;
+
+          /* First get the size each set of items take to span the line
+           * when aligning the items above and below after flowping.
+           */
+          item_sizes = fit_aligned_item_requests (box,
+                                                  priv->orientation,
+                                                  avail_size,
+                                                  priv->row_spacing,
+                                                  &line_length,
+                                                  priv->max_children_per_line,
+                                                  n_children);
+
+          /* Get the available remaining size */
+          avail_size -= (line_length - 1) * priv->column_spacing;
+          for (i = 0; i < line_length; i++)
+            avail_size -= item_sizes[i].minimum_size;
+
+          if (avail_size > 0)
+            extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
+
+          for (iter = g_sequence_get_begin_iter (priv->children);
+               !g_sequence_iter_is_end (iter);)
+            {
+              iter = get_largest_size_for_line_in_opposing_orientation (box,
+                                                                        GTK_ORIENTATION_VERTICAL,
+                                                                        iter,
+                                                                        line_length,
+                                                                        item_sizes,
+                                                                        extra_pixels,
+                                                                        &min_line_width,
+                                                                        &nat_line_width);
+
+              /* Its possible the last line only had invisible widgets */
+              if (nat_line_width > 0)
+                {
+                  if (first_line)
+                    first_line = FALSE;
+                  else
+                    {
+                      min_width += priv->column_spacing;
+                      nat_width += priv->column_spacing;
+                    }
+
+                  min_width += min_line_width;
+                  nat_width += nat_line_width;
+                }
+            }
+          g_free (item_sizes);
+        }
+    }
+
+ out:
+  if (minimum_width)
+    *minimum_width = min_width;
+
+  if (natural_width)
+    *natural_width = nat_width;
+}
+
+/* Drawing {{{3 */
+
+static gboolean
+gtk_flow_box_draw (GtkWidget *widget,
+                   cairo_t   *cr)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  GtkAllocation allocation = { 0, };
+  GtkStyleContext* context;
+
+  gtk_widget_get_allocation (GTK_WIDGET (box), &allocation);
+  context = gtk_widget_get_style_context (GTK_WIDGET (box));
+  gtk_render_background (context, cr, 0, 0, allocation.width, allocation.height);
+
+  GTK_WIDGET_CLASS (gtk_flow_box_parent_class)->draw (widget, cr);
+
+  if (priv->rubberband_first && priv->rubberband_last)
+    {
+      GSequenceIter *iter, *iter1, *iter2;
+      GdkRectangle line_rect, rect;
+      GArray *lines;
+      gboolean vertical;
+
+      vertical = priv->orientation == GTK_ORIENTATION_VERTICAL;
+
+      cairo_save (cr);
+
+      context = gtk_widget_get_style_context (widget);
+      gtk_style_context_save (context);
+      gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
+
+      iter1 = CHILD_PRIV (priv->rubberband_first)->iter;
+      iter2 = CHILD_PRIV (priv->rubberband_last)->iter;
+
+      if (g_sequence_iter_compare (iter2, iter1) < 0)
+        {
+          iter = iter1;
+          iter1 = iter2;
+          iter2 = iter;
+        }
+
+      line_rect.width = 0;
+      lines = g_array_new (FALSE, FALSE, sizeof (GdkRectangle));
+
+      for (iter = iter1;
+           !g_sequence_iter_is_end (iter);
+           iter = g_sequence_iter_next (iter))
+        {
+          GtkWidget *child;
+
+          child = g_sequence_get (iter);
+          gtk_widget_get_allocation (GTK_WIDGET (child), &rect);
+          if (line_rect.width == 0)
+            line_rect = rect;
+          else
+            {
+              if ((vertical && rect.x == line_rect.x) ||
+                  (!vertical && rect.y == line_rect.y))
+                gdk_rectangle_union (&rect, &line_rect, &line_rect);
+              else
+                {
+                  g_array_append_val (lines, line_rect);
+                  line_rect = rect;
+                }
+            }
+
+          if (g_sequence_iter_compare (iter, iter2) == 0)
+            break;
+        }
+
+      if (line_rect.width != 0)
+        g_array_append_val (lines, line_rect);
+
+      if (lines->len > 0)
+        {
+          GtkStateFlags state;
+          cairo_path_t *path;
+          GtkBorder border;
+          GdkRGBA border_color;
+
+          if (vertical)
+            path_from_vertical_line_rects (cr, (GdkRectangle *)lines->data, lines->len);
+          else
+            path_from_horizontal_line_rects (cr, (GdkRectangle *)lines->data, lines->len);
+
+          /* For some reason we need to copy and reapply the path,
+           * or it gets eaten by gtk_render_background()
+           */
+          path = cairo_copy_path (cr);
+
+          cairo_save (cr);
+          cairo_clip (cr);
+          gtk_widget_get_allocation (widget, &allocation);
+          gtk_render_background (context, cr,
+                                 0, 0,
+                                 allocation.width, allocation.height);
+          cairo_restore (cr);
+
+          cairo_append_path (cr, path);
+          cairo_path_destroy (path);
+
+          state = gtk_widget_get_state_flags (widget);
+          gtk_style_context_get_border_color (context, state, &border_color);
+          gtk_style_context_get_border (context, state, &border);
+
+          cairo_set_line_width (cr, border.left);
+          gdk_cairo_set_source_rgba (cr, &border_color);
+          cairo_stroke (cr);
+        }
+      g_array_free (lines, TRUE);
+
+      gtk_style_context_restore (context);
+      cairo_restore (cr);
+    }
+
+  return TRUE;
+}
+
+/* Autoscrolling {{{3 */
+
+static void
+remove_autoscroll (GtkFlowBox *box)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  if (priv->autoscroll_id)
+    {
+      gtk_widget_remove_tick_callback (GTK_WIDGET (box), priv->autoscroll_id);
+      priv->autoscroll_id = 0;
+    }
+
+  priv->autoscroll_mode = GTK_SCROLL_NONE;
+}
+
+static gboolean
+autoscroll_cb (GtkWidget     *widget,
+               GdkFrameClock *frame_clock,
+               gpointer       data)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (data);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  GtkAdjustment *adjustment;
+  gdouble factor;
+  gdouble increment;
+  gdouble value;
+
+  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
+    adjustment = priv->vadjustment;
+  else
+    adjustment = priv->hadjustment;
+
+  switch (priv->autoscroll_mode)
+    {
+    case GTK_SCROLL_STEP_FORWARD:
+      factor = AUTOSCROLL_FACTOR;
+      break;
+    case GTK_SCROLL_STEP_BACKWARD:
+      factor = - AUTOSCROLL_FACTOR;
+      break;
+    case GTK_SCROLL_PAGE_FORWARD:
+      factor = AUTOSCROLL_FACTOR_FAST;
+      break;
+    case GTK_SCROLL_PAGE_BACKWARD:
+      factor = - AUTOSCROLL_FACTOR_FAST;
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+  increment = gtk_adjustment_get_step_increment (adjustment) / factor;
+
+  value = gtk_adjustment_get_value (adjustment);
+  value += increment;
+  gtk_adjustment_set_value (adjustment, value);
+
+  if (priv->rubberband_select)
+    {
+      gint x, y;
+      GtkFlowBoxChild *child;
+
+      gdk_window_get_device_position (gtk_widget_get_window (widget),
+                                      priv->rubberband_device,
+                                      &x, &y, NULL);
+
+      child = gtk_flow_box_find_child_at_pos (box, x, y);
+
+      gtk_flow_box_update_prelight (box, child);
+      gtk_flow_box_update_active (box, child);
+
+      if (child != NULL)
+        priv->rubberband_last = child;
+    }
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+add_autoscroll (GtkFlowBox *box)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  if (priv->autoscroll_id != 0 ||
+      priv->autoscroll_mode == GTK_SCROLL_NONE)
+    return;
+
+  priv->autoscroll_id = gtk_widget_add_tick_callback (GTK_WIDGET (box),
+                                                      (GtkTickCallback)autoscroll_cb,
+                                                      box,
+                                                      NULL);
+}
+
+static gboolean
+get_view_rect (GtkFlowBox   *box,
+               GdkRectangle *rect)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  GtkWidget *parent;
+  GdkWindow *view;
+
+  parent = gtk_widget_get_parent (GTK_WIDGET (box));
+  if (GTK_IS_VIEWPORT (parent))
+    {
+      view = gtk_viewport_get_view_window (GTK_VIEWPORT (parent));
+      rect->x = gtk_adjustment_get_value (priv->hadjustment);
+      rect->y = gtk_adjustment_get_value (priv->vadjustment);
+      rect->width = gdk_window_get_width (view);
+      rect->height = gdk_window_get_height (view);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+update_autoscroll_mode (GtkFlowBox *box,
+                        gint        x,
+                        gint        y)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  GtkScrollType mode = GTK_SCROLL_NONE;
+  GdkRectangle rect;
+  gint size, pos;
+
+  if (priv->rubberband_select && get_view_rect (box, &rect))
+    {
+      if (priv->orientation == GTK_ORIENTATION_VERTICAL)
+        {
+          size = rect.width;
+          pos = x - rect.x;
+        }
+      else
+        {
+          size = rect.height;
+          pos = y - rect.y;
+        }
+
+      if (pos < 0 - AUTOSCROLL_FAST_DISTANCE)
+        mode = GTK_SCROLL_PAGE_BACKWARD;
+      else if (pos > size + AUTOSCROLL_FAST_DISTANCE)
+        mode = GTK_SCROLL_PAGE_FORWARD;
+      else if (pos < 0)
+        mode = GTK_SCROLL_STEP_BACKWARD;
+      else if (pos > size)
+        mode = GTK_SCROLL_STEP_FORWARD;
+    }
+
+  if (mode != priv->autoscroll_mode)
+    {
+      remove_autoscroll (box);
+      priv->autoscroll_mode = mode;
+      add_autoscroll (box);
+    }
+}
+
+/* Event handling {{{3 */
+
+static gboolean
+gtk_flow_box_enter_notify_event (GtkWidget        *widget,
+                                 GdkEventCrossing *event)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxChild *child;
+
+  if (event->window != gtk_widget_get_window (GTK_WIDGET (box)))
+    return FALSE;
+
+  child = gtk_flow_box_find_child_at_pos (box, event->x, event->y);
+  gtk_flow_box_update_prelight (box, child);
+  gtk_flow_box_update_active (box, child);
+
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_leave_notify_event (GtkWidget        *widget,
+                                 GdkEventCrossing *event)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxChild *child = NULL;
+
+  if (event->window != gtk_widget_get_window (GTK_WIDGET (box)))
+    return FALSE;
+
+  if (event->detail != GDK_NOTIFY_INFERIOR)
+    child = NULL;
+  else
+    child = gtk_flow_box_find_child_at_pos (box, event->x, event->y);
+
+  gtk_flow_box_update_prelight (box, child);
+  gtk_flow_box_update_active (box, child);
+
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_motion_notify_event (GtkWidget      *widget,
+                                  GdkEventMotion *event)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  GtkFlowBoxChild *child;
+  GdkWindow *window;
+  GdkWindow *event_window;
+  gint relative_x;
+  gint relative_y;
+  gdouble parent_x;
+  gdouble parent_y;
+
+  window = gtk_widget_get_window (GTK_WIDGET (box));
+  event_window = event->window;
+  relative_x = event->x;
+  relative_y = event->y;
+
+  while ((event_window != NULL) && (event_window != window))
+    {
+      gdk_window_coords_to_parent (event_window,
+                                   relative_x, relative_y,
+                                   &parent_x, &parent_y);
+      relative_x = parent_x;
+      relative_y = parent_y;
+      event_window = gdk_window_get_effective_parent (event_window);
+    }
+
+  child = gtk_flow_box_find_child_at_pos (box, relative_x, relative_y);
+  gtk_flow_box_update_prelight (box, child);
+  gtk_flow_box_update_active (box, child);
+
+  if (priv->track_motion)
+    {
+      if (!priv->rubberband_select &&
+          (event->x - priv->button_down_x) * (event->x - priv->button_down_x) +
+          (event->y - priv->button_down_y) * (event->y - priv->button_down_y) > RUBBERBAND_START_DISTANCE * 
RUBBERBAND_START_DISTANCE)
+        {
+          priv->rubberband_select = TRUE;
+          priv->rubberband_first = gtk_flow_box_find_child_at_pos (box, priv->button_down_x, 
priv->button_down_y);
+        }
+
+      if (priv->rubberband_select)
+        {
+          if (priv->rubberband_first == NULL)
+            priv->rubberband_first = child;
+          if (child != NULL)
+            priv->rubberband_last = child;
+
+          update_autoscroll_mode (box, event->x, event->y);
+        }
+    }
+
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_button_press_event (GtkWidget      *widget,
+                                 GdkEventButton *event)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  GtkFlowBoxChild *child;
+
+  if (event->button == GDK_BUTTON_PRIMARY)
+    {
+      child = gtk_flow_box_find_child_at_pos (box, event->x, event->y);
+      if (child != NULL)
+        {
+          priv->active_child = child;
+          priv->active_child_active = TRUE;
+          gtk_widget_queue_draw (GTK_WIDGET (box));
+          if (event->type == GDK_2BUTTON_PRESS &&
+              !priv->activate_on_single_click)
+            {
+              g_signal_emit (box, signals[CHILD_ACTIVATED], 0, child);
+              return TRUE;
+            }
+        }
+
+      if (priv->selection_mode == GTK_SELECTION_MULTIPLE)
+        {
+          priv->track_motion = TRUE;
+          priv->rubberband_select = FALSE;
+          priv->rubberband_first = NULL;
+          priv->rubberband_last = NULL;
+          priv->button_down_x = event->x;
+          priv->button_down_y = event->y;
+          priv->rubberband_device = gdk_event_get_device ((GdkEvent*)event);
+        }
+    }
+
+  return FALSE;
+}
+
+static gboolean
+gtk_flow_box_button_release_event (GtkWidget      *widget,
+                                   GdkEventButton *event)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gboolean modify_selection;
+  gboolean extend_selection;
+
+  if (event->button == GDK_BUTTON_PRIMARY)
+    {
+      if (priv->active_child != NULL && priv->active_child_active)
+        {
+          get_current_selection_modifiers (GTK_WIDGET (box), &modify_selection, &extend_selection);
+
+          if (priv->activate_on_single_click)
+            gtk_flow_box_select_and_activate (box, priv->active_child);
+          else
+            gtk_flow_box_update_selection (box, priv->active_child, TRUE, extend_selection);
+        }
+
+      priv->active_child = NULL;
+      priv->active_child_active = FALSE;
+      gtk_widget_queue_draw (GTK_WIDGET (box));
+  }
+
+  remove_autoscroll (box);
+  priv->track_motion = FALSE;
+  if (priv->rubberband_select)
+    {
+      gtk_flow_box_select_all_between (box, priv->rubberband_first, priv->rubberband_last);
+      priv->rubberband_first = NULL;
+      priv->rubberband_last = NULL;
+      priv->rubberband_select = FALSE;
+      priv->rubberband_device = NULL;
+    }
+
+  return FALSE;
+}
+
+/* Realize and map {{{3 */
+
+static void
+gtk_flow_box_realize (GtkWidget *widget)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkAllocation allocation;
+  GdkWindowAttr attributes = {0};
+  GdkWindow *window;
+
+  gtk_widget_get_allocation (GTK_WIDGET (box), &allocation);
+  gtk_widget_set_realized (GTK_WIDGET (box), TRUE);
+
+  attributes.x = allocation.x;
+  attributes.y = allocation.y;
+  attributes.width = allocation.width;
+  attributes.height = allocation.height;
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.event_mask = gtk_widget_get_events (GTK_WIDGET (box))
+                                | GDK_ENTER_NOTIFY_MASK
+                                | GDK_LEAVE_NOTIFY_MASK
+                                | GDK_POINTER_MOTION_MASK
+                                | GDK_EXPOSURE_MASK
+                                | GDK_BUTTON_PRESS_MASK
+                                | GDK_BUTTON_RELEASE_MASK;
+  attributes.wclass = GDK_INPUT_OUTPUT;
+
+  window = gdk_window_new (gtk_widget_get_parent_window (GTK_WIDGET (box)),
+                           &attributes, GDK_WA_X | GDK_WA_Y);
+  gtk_style_context_set_background (gtk_widget_get_style_context (GTK_WIDGET (box)), window);
+  gtk_widget_register_window (GTK_WIDGET (box), window);
+  gtk_widget_set_window (GTK_WIDGET (box), window);
+}
+
+static void
+gtk_flow_box_unmap (GtkWidget *widget)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+
+  remove_autoscroll (box);
+
+  GTK_WIDGET_CLASS (gtk_flow_box_parent_class)->unmap (widget);
+}
+
+/* GtkContainer implementation {{{2 */
+
+static void
+gtk_flow_box_add (GtkContainer *container,
+                  GtkWidget    *child)
+{
+  gtk_flow_box_insert (GTK_FLOW_BOX (container), child, -1);
+}
+
+static void
+gtk_flow_box_remove (GtkContainer *container,
+                     GtkWidget    *widget)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (container);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gboolean was_visible;
+  gboolean was_selected;
+  GtkFlowBoxChild *child;
+
+  if (GTK_IS_FLOW_BOX_CHILD (widget))
+    child = GTK_FLOW_BOX_CHILD (widget);
+  else
+    {
+      child = (GtkFlowBoxChild*)gtk_widget_get_parent (widget);
+      if (!GTK_IS_FLOW_BOX_CHILD (child))
+        {
+          g_warning ("Tried to remove non-child %p\n", widget);
+          return;
+        }
+    }
+
+  was_visible = child_is_visible (GTK_WIDGET (child));
+  was_selected = CHILD_PRIV (child)->selected;
+
+  if (child == priv->prelight_child)
+    priv->prelight_child = NULL;
+  if (child == priv->active_child)
+    priv->active_child = NULL;
+  if (child == priv->selected_child)
+    priv->selected_child = NULL;
+
+  gtk_widget_unparent (GTK_WIDGET (child));
+  g_sequence_remove (CHILD_PRIV (child)->iter);
+
+  if (was_visible && gtk_widget_get_visible (GTK_WIDGET (box)))
+    gtk_widget_queue_resize (GTK_WIDGET (box));
+
+  if (was_selected)
+    g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+}
+
+static void
+gtk_flow_box_forall (GtkContainer *container,
+                     gboolean      include_internals,
+                     GtkCallback   callback,
+                     gpointer      callback_target)
+{
+  GSequenceIter *iter;
+  GtkWidget *child;
+
+  iter = g_sequence_get_begin_iter (BOX_PRIV (container)->children);
+  while (!g_sequence_iter_is_end (iter))
+    {
+      child = g_sequence_get (iter);
+      iter = g_sequence_iter_next (iter);
+      callback (child, callback_target);
+    }
+}
+
+static GType
+gtk_flow_box_child_type (GtkContainer *container)
+{
+  return GTK_TYPE_FLOW_BOX_CHILD;
+}
+
+/* Keynav {{{2 */
+
+static gboolean
+gtk_flow_box_focus (GtkWidget        *widget,
+                    GtkDirectionType  direction)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (widget);
+  GtkWidget *focus_child;
+  GSequenceIter *iter;
+  GtkFlowBoxChild *next_focus_child;
+
+  focus_child = gtk_container_get_focus_child (GTK_CONTAINER (box));
+  next_focus_child = NULL;
+
+  if (focus_child != NULL)
+    {
+      if (gtk_widget_child_focus (focus_child, direction))
+        return TRUE;
+
+      iter = CHILD_PRIV (focus_child)->iter;
+
+      if (direction == GTK_DIR_LEFT || direction == GTK_DIR_TAB_BACKWARD)
+        iter = gtk_flow_box_get_previous_focusable (box, iter);
+      else if (direction == GTK_DIR_RIGHT || direction == GTK_DIR_TAB_FORWARD)
+        iter = gtk_flow_box_get_next_focusable (box, iter);
+      else if (direction == GTK_DIR_UP)
+        iter = gtk_flow_box_get_above_focusable (box, iter);
+      else if (direction == GTK_DIR_DOWN)
+        iter = gtk_flow_box_get_below_focusable (box, iter);
+
+      if (iter != NULL && !g_sequence_iter_is_end (iter))
+        next_focus_child = g_sequence_get (iter);
+    }
+  else
+    {
+      if (BOX_PRIV (box)->selected_child)
+        next_focus_child = BOX_PRIV (box)->selected_child;
+      else
+        {
+          if (direction == GTK_DIR_UP || direction == GTK_DIR_TAB_BACKWARD)
+            iter = gtk_flow_box_get_last_focusable (box);
+          else
+            iter = gtk_flow_box_get_first_focusable (box);
+
+          if (iter != NULL && !g_sequence_iter_is_end (iter))
+            next_focus_child = g_sequence_get (iter);
+        }
+    }
+
+  if (next_focus_child == NULL)
+    {
+      if (direction == GTK_DIR_UP || direction == GTK_DIR_DOWN ||
+          direction == GTK_DIR_LEFT || direction == GTK_DIR_RIGHT)
+        {
+          if (gtk_widget_keynav_failed (GTK_WIDGET (box), direction))
+            return TRUE;
+        }
+
+      return FALSE;
+    }
+
+  if (gtk_widget_child_focus (GTK_WIDGET (next_focus_child), direction))
+    return TRUE;
+
+  return TRUE;
+}
+
+static void
+gtk_flow_box_add_move_binding (GtkBindingSet   *binding_set,
+                               guint            keyval,
+                               GdkModifierType  modmask,
+                               GtkMovementStep  step,
+                               gint             count)
+{
+  GdkDisplay *display;
+  GdkModifierType extend_mod_mask = GDK_SHIFT_MASK;
+  GdkModifierType modify_mod_mask = GDK_CONTROL_MASK;
+
+  display = gdk_display_get_default ();
+  if (display)
+    {
+      extend_mod_mask = gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+                                                      GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+      modify_mod_mask = gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+                                                      GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+    }
+
+  gtk_binding_entry_add_signal (binding_set, keyval, modmask,
+                                "move-cursor", 2,
+                                GTK_TYPE_MOVEMENT_STEP, step,
+                                G_TYPE_INT, count,
+                                NULL);
+  gtk_binding_entry_add_signal (binding_set, keyval, modmask | extend_mod_mask,
+                                "move-cursor", 2,
+                                GTK_TYPE_MOVEMENT_STEP, step,
+                                G_TYPE_INT, count,
+                                NULL);
+  gtk_binding_entry_add_signal (binding_set, keyval, modmask | modify_mod_mask,
+                                "move-cursor", 2,
+                                GTK_TYPE_MOVEMENT_STEP, step,
+                                G_TYPE_INT, count,
+                                NULL);
+  gtk_binding_entry_add_signal (binding_set, keyval, modmask | extend_mod_mask | modify_mod_mask,
+                                "move-cursor", 2,
+                                GTK_TYPE_MOVEMENT_STEP, step,
+                                G_TYPE_INT, count,
+                                NULL);
+}
+
+static void
+gtk_flow_box_activate_cursor_child (GtkFlowBox *box)
+{
+  gtk_flow_box_select_and_activate (box, BOX_PRIV (box)->cursor_child);
+}
+
+static void
+gtk_flow_box_toggle_cursor_child (GtkFlowBox *box)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  if (priv->cursor_child == NULL)
+    return;
+
+  if ((priv->selection_mode == GTK_SELECTION_SINGLE ||
+       priv->selection_mode == GTK_SELECTION_MULTIPLE) &&
+      CHILD_PRIV (priv->cursor_child)->selected)
+    gtk_flow_box_unselect_child_info (box, priv->cursor_child);
+  else
+    gtk_flow_box_select_and_activate (box, priv->cursor_child);
+}
+
+static void
+gtk_flow_box_move_cursor (GtkFlowBox      *box,
+                          GtkMovementStep  step,
+                          gint             count)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+  gboolean modify_selection;
+  gboolean extend_selection;
+  GtkFlowBoxChild *child;
+  GtkFlowBoxChild *prev;
+  GtkFlowBoxChild *next;
+  GtkAllocation allocation;
+  gint page_size;
+  GSequenceIter *iter;
+  gint start;
+  GtkAdjustment *adjustment;
+  gboolean vertical;
+
+  vertical = priv->orientation == GTK_ORIENTATION_VERTICAL;
+
+  get_current_selection_modifiers (GTK_WIDGET (box), &modify_selection, &extend_selection);
+
+  if (vertical)
+    {
+       switch (step)
+         {
+         case GTK_MOVEMENT_VISUAL_POSITIONS:
+           step = GTK_MOVEMENT_DISPLAY_LINES;
+           break;
+         case GTK_MOVEMENT_DISPLAY_LINES:
+           step = GTK_MOVEMENT_VISUAL_POSITIONS;
+           break;
+         default: ;
+         }
+    }
+
+  child = NULL;
+  switch (step)
+    {
+    case GTK_MOVEMENT_VISUAL_POSITIONS:
+      if (priv->cursor_child != NULL)
+        {
+          iter = CHILD_PRIV (priv->cursor_child)->iter;
+          if (gtk_widget_get_direction (GTK_WIDGET (box)) == GTK_TEXT_DIR_RTL)
+            count = - count;
+
+          while (count < 0 && iter != NULL)
+            {
+              iter = gtk_flow_box_get_previous_focusable (box, iter);
+              count = count + 1;
+            }
+          while (count > 0 && iter != NULL)
+            {
+              iter = gtk_flow_box_get_next_focusable (box, iter);
+              count = count - 1;
+            }
+
+          if (iter != NULL && !g_sequence_iter_is_end (iter))
+            child = g_sequence_get (iter);
+        }
+      break;
+
+    case GTK_MOVEMENT_BUFFER_ENDS:
+      if (count < 0)
+        iter = gtk_flow_box_get_first_focusable (box);
+      else
+        iter = gtk_flow_box_get_last_focusable (box);
+      if (iter != NULL && !g_sequence_iter_is_end (iter))
+        child = g_sequence_get (iter);
+      break;
+
+    case GTK_MOVEMENT_DISPLAY_LINES:
+      if (priv->cursor_child != NULL)
+        {
+          iter = CHILD_PRIV (priv->cursor_child)->iter;
+
+          while (count < 0 && iter != NULL)
+            {
+              iter = gtk_flow_box_get_above_focusable (box, iter);
+              count = count + 1;
+            }
+          while (count > 0 && iter != NULL)
+            {
+              iter = gtk_flow_box_get_below_focusable (box, iter);
+              count = count - 1;
+            }
+
+          if (iter != NULL && !g_sequence_iter_is_end (iter))
+            child = g_sequence_get (iter);
+        }
+      break;
+
+    case GTK_MOVEMENT_PAGES:
+      page_size = 100;
+      adjustment = vertical ? priv->hadjustment : priv->vadjustment;
+      if (adjustment)
+        page_size = gtk_adjustment_get_page_increment (adjustment);
+
+      if (priv->cursor_child != NULL)
+        {
+          child = priv->cursor_child;
+          iter = CHILD_PRIV (child)->iter;
+          gtk_widget_get_allocation (GTK_WIDGET (child), &allocation);
+          start = vertical ? allocation.x : allocation.y;
+
+          if (count < 0)
+            {
+              gint i = 0;
+
+              /* Up */
+              while (iter != NULL)
+                {
+                  iter = gtk_flow_box_get_previous_focusable (box, iter);
+                  if (iter == NULL)
+                    break;
+
+                  prev = g_sequence_get (iter);
+
+                  /* go up an even number of rows */
+                  if (i % priv->cur_children_per_line == 0)
+                    {
+                      gtk_widget_get_allocation (GTK_WIDGET (prev), &allocation);
+                      if ((vertical ? allocation.x : allocation.y) < start - page_size)
+                        break;
+                    }
+
+                  child = prev;
+                  i++;
+                }
+            }
+          else
+            {
+              gint i = 0;
+
+              /* Down */
+              while (!g_sequence_iter_is_end (iter))
+                {
+                  iter = gtk_flow_box_get_next_focusable (box, iter);
+                  if (g_sequence_iter_is_end (iter))
+                    break;
+
+                  next = g_sequence_get (iter);
+
+                  if (i % priv->cur_children_per_line == 0)
+                    {
+                      gtk_widget_get_allocation (GTK_WIDGET (next), &allocation);
+                      if ((vertical ? allocation.x : allocation.y) > start + page_size)
+                        break;
+                    }
+
+                  child = next;
+                  i++;
+                }
+            }
+          gtk_widget_get_allocation (GTK_WIDGET (child), &allocation);
+        }
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+
+  if (child == NULL || child == priv->cursor_child)
+    {
+      GtkDirectionType direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
+
+      if (!gtk_widget_keynav_failed (GTK_WIDGET (box), direction))
+        {
+          GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (box));
+
+          if (toplevel)
+            gtk_widget_child_focus (toplevel,
+                                    direction == GTK_DIR_UP ?
+                                    GTK_DIR_TAB_BACKWARD :
+                                    GTK_DIR_TAB_FORWARD);
+
+        }
+
+      return;
+    }
+
+  gtk_flow_box_update_cursor (box, child);
+  gtk_flow_box_update_selection (box, child, modify_selection, extend_selection);
+}
+
+/* Selection {{{2 */
+
+static void
+gtk_flow_box_selected_children_changed (GtkFlowBox *box)
+{
+  _gtk_flow_box_accessible_selection_changed (GTK_WIDGET (box));
+}
+
+/* GObject implementation {{{2 */
+
+static void
+gtk_flow_box_get_property (GObject    *object,
+                           guint       prop_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (object);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, priv->orientation);
+      break;
+    case PROP_HOMOGENEOUS:
+      g_value_set_boolean (value, priv->homogeneous);
+      break;
+    case PROP_COLUMN_SPACING:
+      g_value_set_uint (value, priv->column_spacing);
+      break;
+    case PROP_ROW_SPACING:
+      g_value_set_uint (value, priv->row_spacing);
+      break;
+    case PROP_MIN_CHILDREN_PER_LINE:
+      g_value_set_uint (value, priv->min_children_per_line);
+      break;
+    case PROP_MAX_CHILDREN_PER_LINE:
+      g_value_set_uint (value, priv->max_children_per_line);
+      break;
+    case PROP_SELECTION_MODE:
+      g_value_set_enum (value, priv->selection_mode);
+      break;
+    case PROP_ACTIVATE_ON_SINGLE_CLICK:
+      g_value_set_boolean (value, priv->activate_on_single_click);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_flow_box_set_property (GObject      *object,
+                           guint         prop_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  GtkFlowBox *box = GTK_FLOW_BOX (object);
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  switch (prop_id)
+    {
+    case PROP_ORIENTATION:
+      priv->orientation = g_value_get_enum (value);
+      /* Re-box the children in the new orientation */
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+      break;
+    case PROP_HOMOGENEOUS:
+      gtk_flow_box_set_homogeneous (box, g_value_get_boolean (value));
+      break;
+    case PROP_COLUMN_SPACING:
+      gtk_flow_box_set_column_spacing (box, g_value_get_uint (value));
+      break;
+    case PROP_ROW_SPACING:
+      gtk_flow_box_set_row_spacing (box, g_value_get_uint (value));
+      break;
+    case PROP_MIN_CHILDREN_PER_LINE:
+      gtk_flow_box_set_min_children_per_line (box, g_value_get_uint (value));
+      break;
+    case PROP_MAX_CHILDREN_PER_LINE:
+      gtk_flow_box_set_max_children_per_line (box, g_value_get_uint (value));
+      break;
+    case PROP_SELECTION_MODE:
+      gtk_flow_box_set_selection_mode (box, g_value_get_enum (value));
+      break;
+    case PROP_ACTIVATE_ON_SINGLE_CLICK:
+      gtk_flow_box_set_activate_on_single_click (box, g_value_get_boolean (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_flow_box_finalize (GObject *obj)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (obj);
+
+  if (priv->filter_destroy != NULL)
+    priv->filter_destroy (priv->filter_data);
+  if (priv->sort_destroy != NULL)
+    priv->sort_destroy (priv->sort_data);
+
+  g_sequence_free (priv->children);
+  g_clear_object (&priv->hadjustment);
+  g_clear_object (&priv->vadjustment);
+
+  G_OBJECT_CLASS (gtk_flow_box_parent_class)->finalize (obj);
+}
+
+static void
+gtk_flow_box_class_init (GtkFlowBoxClass *class)
+{
+  GObjectClass      *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass    *widget_class = GTK_WIDGET_CLASS (class);
+  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class);
+  GtkBindingSet     *binding_set;
+
+  object_class->finalize = gtk_flow_box_finalize;
+  object_class->get_property = gtk_flow_box_get_property;
+  object_class->set_property = gtk_flow_box_set_property;
+
+  widget_class->enter_notify_event = gtk_flow_box_enter_notify_event;
+  widget_class->leave_notify_event = gtk_flow_box_leave_notify_event;
+  widget_class->motion_notify_event = gtk_flow_box_motion_notify_event;
+  widget_class->size_allocate = gtk_flow_box_size_allocate;
+  widget_class->realize = gtk_flow_box_realize;
+  widget_class->unmap = gtk_flow_box_unmap;
+  widget_class->focus = gtk_flow_box_focus;
+  widget_class->draw = gtk_flow_box_draw;
+  widget_class->button_press_event = gtk_flow_box_button_press_event;
+  widget_class->button_release_event = gtk_flow_box_button_release_event;
+  widget_class->get_request_mode = gtk_flow_box_get_request_mode;
+  widget_class->get_preferred_width = gtk_flow_box_get_preferred_width;
+  widget_class->get_preferred_height = gtk_flow_box_get_preferred_height;
+  widget_class->get_preferred_height_for_width = gtk_flow_box_get_preferred_height_for_width;
+  widget_class->get_preferred_width_for_height = gtk_flow_box_get_preferred_width_for_height;
+
+  container_class->add = gtk_flow_box_add;
+  container_class->remove = gtk_flow_box_remove;
+  container_class->forall = gtk_flow_box_forall;
+  container_class->child_type = gtk_flow_box_child_type;
+  gtk_container_class_handle_border_width (container_class);
+
+  class->activate_cursor_child = gtk_flow_box_activate_cursor_child;
+  class->toggle_cursor_child = gtk_flow_box_toggle_cursor_child;
+  class->move_cursor = gtk_flow_box_move_cursor;
+  class->select_all = gtk_flow_box_select_all;
+  class->unselect_all = gtk_flow_box_unselect_all;
+  class->selected_children_changed = gtk_flow_box_selected_children_changed;
+
+  g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation");
+
+  /**
+   * GtkFlowBox:selection-mode:
+   *
+   * The selection mode used by the flow  box.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_SELECTION_MODE,
+                                   g_param_spec_enum ("selection-mode",
+                                                      P_("Selection mode"),
+                                                      P_("The selection mode"),
+                                                      GTK_TYPE_SELECTION_MODE,
+                                                      GTK_SELECTION_SINGLE,
+                                                      G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox:activate-on-single-click:
+   *
+   * Determines whether children can be activated with a single
+   * click, or require a double-click.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_ACTIVATE_ON_SINGLE_CLICK,
+                                   g_param_spec_boolean ("activate-on-single-click",
+                                                         P_("Activate on Single Click"),
+                                                         P_("Activate row on a single click"),
+                                                         TRUE,
+                                                         G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox:homogeneous:
+   *
+   * Determines whether all children should be allocated the
+   * same size.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_HOMOGENEOUS,
+                                   g_param_spec_boolean ("homogeneous",
+                                                         P_("Homogeneous"),
+                                                         P_("Whether the children should all be the same 
size"),
+                                                         FALSE,
+                                                         G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox:min-children-per-line:
+   *
+   * The minimum number of children to allocate consecutively
+   * in the given orientation.
+   *
+   * <note><para>Setting the minimum children per line ensures
+   * that a reasonably small height will be requested
+   * for the overall minimum width of the box.</para></note>
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_MIN_CHILDREN_PER_LINE,
+                                   g_param_spec_uint ("min-children-per-line",
+                                                      P_("Minimum Children Per Line"),
+                                                      P_("The minimum number of children to allocate "
+                                                         "consecutively in the given orientation."),
+                                                      0,
+                                                      G_MAXUINT,
+                                                      0,
+                                                      G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox:max-children-per-line:
+   *
+   * The maximum amount of children to request space for consecutively
+   * in the given orientation.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_MAX_CHILDREN_PER_LINE,
+                                   g_param_spec_uint ("max-children-per-line",
+                                                      P_("Maximum Children Per Line"),
+                                                      P_("The maximum amount of children to request space 
for "
+                                                         "consecutively in the given orientation."),
+                                                      0,
+                                                      G_MAXUINT,
+                                                      DEFAULT_MAX_CHILDREN_PER_LINE,
+                                                      G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox:row-spacing:
+   *
+   * The amount of vertical space between two children.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_ROW_SPACING,
+                                   g_param_spec_uint ("row-spacing",
+                                                      P_("Vertical spacing"),
+                                                      P_("The amount of vertical space between two 
children"),
+                                                      0,
+                                                      G_MAXUINT,
+                                                      0,
+                                                      G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox:column-spacing:
+   *
+   * The amount of horizontal space between two children.
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_COLUMN_SPACING,
+                                   g_param_spec_uint ("column-spacing",
+                                                      P_("Horizontal spacing"),
+                                                      P_("The amount of horizontal space between two 
children"),
+                                                      0,
+                                                      G_MAXUINT,
+                                                      0,
+                                                      G_PARAM_READWRITE));
+
+  /**
+   * GtkFlowBox::child-activated:
+   * @box: the #GtkFlowBox on which the signal is emitted
+   * @child: the child that is activated
+   *
+   * The ::child-activated signal is emitted when a child has been
+   * activated by the user.
+   */
+  signals[CHILD_ACTIVATED] = g_signal_new ("child-activated",
+                                           GTK_TYPE_FLOW_BOX,
+                                           G_SIGNAL_RUN_LAST,
+                                           G_STRUCT_OFFSET (GtkFlowBoxClass, child_activated),
+                                           NULL, NULL,
+                                           g_cclosure_marshal_VOID__OBJECT,
+                                           G_TYPE_NONE, 1,
+                                           GTK_TYPE_WIDGET);
+
+  /**
+   * GtkFlowBox::selected-children-changed:
+   * @box: the #GtkFlowBox on wich the signal is emitted
+   *
+   * The ::selected-children-changed signal is emitted when the
+   * set of selected children changes.
+   *
+   * Use gtk_flow_box_selected_foreach() or
+   * gtk_flow_box_get_selected_children() to obtain the
+   * selected children.
+   */
+  signals[SELECTED_CHILDREN_CHANGED] = g_signal_new ("selected-children-changed",
+                                                     GTK_TYPE_FLOW_BOX,
+                                                     G_SIGNAL_RUN_FIRST,
+                                                     G_STRUCT_OFFSET (GtkFlowBoxClass, 
selected_children_changed),
+                                                     NULL, NULL,
+                                                     g_cclosure_marshal_VOID__VOID,
+                                                     G_TYPE_NONE, 0);
+
+  /**
+   * GtkFlowBox::activate-cursor-child:
+   * @box: the #GtkFlowBox on which the signal is emitted
+   *
+   * The ::activate-cursor-child signal is a
+   * <link linkend="keybinding-signals">keybinding signal</link>
+   * which gets emitted when the user activates the @box.
+   */
+  signals[ACTIVATE_CURSOR_CHILD] = g_signal_new ("activate-cursor-child",
+                                                 GTK_TYPE_FLOW_BOX,
+                                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                                                 G_STRUCT_OFFSET (GtkFlowBoxClass, activate_cursor_child),
+                                                 NULL, NULL,
+                                                 g_cclosure_marshal_VOID__VOID,
+                                                 G_TYPE_NONE, 0);
+
+  /**
+   * GtkFlowBox::toggle-cursor-child:
+   * @box: the #GtkFlowBox on which the signal is emitted
+   *
+   * The ::toggle-cursor-child signal is a
+   * <link linkend="keybinding-signals">keybinding signal</link>
+   * which toggles the selection of the child that has the focus.
+   *
+   * The default binding for this signal is Ctrl-Space.
+   */
+  signals[TOGGLE_CURSOR_CHILD] = g_signal_new ("toggle-cursor-child",
+                                               GTK_TYPE_FLOW_BOX,
+                                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                                               G_STRUCT_OFFSET (GtkFlowBoxClass, toggle_cursor_child),
+                                               NULL, NULL,
+                                               g_cclosure_marshal_VOID__VOID,
+                                               G_TYPE_NONE, 0);
+
+  /**
+   * GtkFlowBox::move-cursor:
+   * @box: the #GtkFlowBox on which the signal is emitted
+   * @step: the granularity fo the move, as a #GtkMovementStep
+   * @count: the number of @step units to move
+   *
+   * The ::move-cursor signal is a
+   * <link linkend="keybinding-signals">keybinding signal</link>
+   * which gets emitted when the user initiates a cursor movement.
+   * If the cursor is not visible in @text_view, this signal causes
+   * the viewport to be moved instead.
+   *
+   * Applications should not connect to it, but may emit it with
+   * g_signal_emit_by_name() if they need to control the cursor
+   * programmatically.
+   *
+   * The default bindings for this signal come in two variants,
+   * the variant with the Shift modifier extends the selection,
+   * the variant without the Shift modifer does not.
+   * There are too many key combinations to list them all here.
+   * <itemizedlist>
+   * <listitem>Arrow keys move by individual children</listitem>
+   * <listitem>Home/End keys move to the ends of the box</listitem>
+   * <listitem>PageUp/PageDown keys move vertically by pages</listitem>
+   * </itemizedlist>
+   */
+  signals[MOVE_CURSOR] = g_signal_new ("move-cursor",
+                                       GTK_TYPE_FLOW_BOX,
+                                       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                                       G_STRUCT_OFFSET (GtkFlowBoxClass, move_cursor),
+                                       NULL, NULL,
+                                       _gtk_marshal_VOID__ENUM_INT,
+                                       G_TYPE_NONE, 2,
+                                       GTK_TYPE_MOVEMENT_STEP, G_TYPE_INT);
+  /**
+   * GtkFlowBox::select-all:
+   * @box: the #GtkFlowBox on which the signal is emitted
+   *
+   * The ::select-all signal is a
+   * <link linkend="keybinding-signals">keybinding signal</link>
+   * which gets emitted to select all children of the box, if
+   * the selection mode permits it.
+   *
+   * The default bindings for this signal is Ctrl-a.
+   */
+  signals[SELECT_ALL] = g_signal_new ("select-all",
+                                      GTK_TYPE_FLOW_BOX,
+                                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                                      G_STRUCT_OFFSET (GtkFlowBoxClass, select_all),
+                                      NULL, NULL,
+                                      g_cclosure_marshal_VOID__VOID,
+                                      G_TYPE_NONE, 0);
+
+  /**
+   * GtkFlowBox::unselect-all:
+   * @box: the #GtkFlowBox on which the signal is emitted
+   *
+   * The ::unselect-all signal is a
+   * <link linkend="keybinding-signals">keybinding signal</link>
+   * which gets emitted to unselect all children of the box, if
+   * the selection mode permits it.
+   *
+   * The default bindings for this signal is Ctrl-Shift-a.
+   */
+  signals[UNSELECT_ALL] = g_signal_new ("unselect-all",
+                                      GTK_TYPE_FLOW_BOX,
+                                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                                      G_STRUCT_OFFSET (GtkFlowBoxClass, unselect_all),
+                                      NULL, NULL,
+                                      g_cclosure_marshal_VOID__VOID,
+                                      G_TYPE_NONE, 0);
+
+  widget_class->activate_signal = signals[ACTIVATE_CURSOR_CHILD];
+
+  binding_set = gtk_binding_set_by_class (class);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Home, 0,
+                                 GTK_MOVEMENT_BUFFER_ENDS, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Home, 0,
+                                 GTK_MOVEMENT_BUFFER_ENDS, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_End, 0,
+                                 GTK_MOVEMENT_BUFFER_ENDS, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_End, 0,
+                                 GTK_MOVEMENT_BUFFER_ENDS, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Up, 0,
+                                 GTK_MOVEMENT_DISPLAY_LINES, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Up, 0,
+                                 GTK_MOVEMENT_DISPLAY_LINES, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Down, 0,
+                                 GTK_MOVEMENT_DISPLAY_LINES, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Down, 0,
+                                 GTK_MOVEMENT_DISPLAY_LINES, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Page_Up, 0,
+                                 GTK_MOVEMENT_PAGES, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0,
+                                 GTK_MOVEMENT_PAGES, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Page_Down, 0,
+                                 GTK_MOVEMENT_PAGES, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0,
+                                 GTK_MOVEMENT_PAGES, 1);
+
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Right, 0,
+                                 GTK_MOVEMENT_VISUAL_POSITIONS, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Right, 0,
+                                 GTK_MOVEMENT_VISUAL_POSITIONS, 1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_Left, 0,
+                                 GTK_MOVEMENT_VISUAL_POSITIONS, -1);
+  gtk_flow_box_add_move_binding (binding_set, GDK_KEY_KP_Left, 0,
+                                 GTK_MOVEMENT_VISUAL_POSITIONS, -1);
+
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK,
+                                "toggle-cursor-child", 0, NULL);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK,
+                                "toggle-cursor-child", 0, NULL);
+
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
+                                "select-all", 0);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+                                "unselect-all", 0);
+
+  gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_FLOW_BOX_ACCESSIBLE);
+}
+
+static void
+gtk_flow_box_init (GtkFlowBox *box)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  gtk_widget_set_has_window (GTK_WIDGET (box), TRUE);
+  gtk_widget_set_redraw_on_allocate (GTK_WIDGET (box), TRUE);
+
+  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
+  priv->selection_mode = GTK_SELECTION_SINGLE;
+  priv->max_children_per_line = DEFAULT_MAX_CHILDREN_PER_LINE;
+  priv->column_spacing = 0;
+  priv->row_spacing = 0;
+  priv->activate_on_single_click = TRUE;
+
+  priv->children = g_sequence_new (NULL);
+}
+ 
+ /* Public API {{{2 */
+
+/**
+ * gtk_flow_box_new:
+ *
+ * Creates a GtkFlowBox.
+ *
+ * Returns: a new #GtkFlowBox container
+ *
+ * Since: 3.12
+ */
+GtkWidget *
+gtk_flow_box_new (void)
+{
+  return (GtkWidget *)g_object_new (GTK_TYPE_FLOW_BOX, NULL);
+}
+
+/**
+ * gtk_flow_box_insert:
+ * @box: a #GtkFlowBox
+ * @widget: the #GtkWidget to add
+ * @position: the position to insert @child in
+ *
+ * Inserts the @widget into @box at @position.
+ *
+ * If a sort function is set, the widget will actually be inserted
+ * at the calculated position and this function has the same effect
+ * as gtk_container_add().
+ *
+ * If @position is -1, or larger than the total number of children
+ * in the @box, then the @widget will be appended to the end.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_insert (GtkFlowBox *box,
+                     GtkWidget  *widget,
+                     gint        position)
+{
+  GtkFlowBoxPrivate *priv;
+  GtkFlowBoxChild *child;
+  GSequenceIter *iter;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+  g_return_if_fail (GTK_IS_WIDGET (widget));
+
+  priv = BOX_PRIV (box);
+
+  if (GTK_IS_FLOW_BOX_CHILD (widget))
+    child = GTK_FLOW_BOX_CHILD (widget);
+  else
+    {
+      child = GTK_FLOW_BOX_CHILD (gtk_flow_box_child_new ());
+      gtk_widget_show (GTK_WIDGET (child));
+      gtk_container_add (GTK_CONTAINER (child), widget);
+    }
+
+  if (priv->sort_func != NULL)
+    iter = g_sequence_insert_sorted (priv->children, child,
+                                     (GCompareDataFunc)gtk_flow_box_sort, box);
+  else if (position == 0)
+    iter = g_sequence_prepend (priv->children, child);
+  else if (position == -1)
+    iter = g_sequence_append (priv->children, child);
+  else
+    {
+      GSequenceIter *pos;
+      pos = g_sequence_get_iter_at_pos (priv->children, position);
+      iter = g_sequence_insert_before (pos, child);
+    }
+
+  CHILD_PRIV (child)->iter = iter;
+  gtk_widget_set_parent (GTK_WIDGET (child), GTK_WIDGET (box));
+  gtk_flow_box_apply_filter (box, child);
+}
+
+/**
+ * gtk_flow_box_get_child_at_index:
+ * @box: a #GtkFlowBox
+ * @idx: the position of the child
+ *
+ * Gets the nth child in the @box.
+ *
+ * Returns: (transfer none): the child widget, which will
+ *     always be a #GtkFlowBoxChild
+ *
+ * Since: 3.12
+ */
+GtkFlowBoxChild *
+gtk_flow_box_get_child_at_index (GtkFlowBox *box,
+                                 gint        idx)
+{
+  GSequenceIter *iter;
+
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), NULL);
+
+  iter = g_sequence_get_iter_at_pos (BOX_PRIV (box)->children, idx);
+  if (iter)
+    return g_sequence_get (iter);
+
+  return NULL;
+}
+
+/**
+ * gtk_flow_box_set_hadjustment:
+ * @box: a #GtkFlowBox
+ * @adjustment: an adjustment which should be adjusted
+ *    when the focus is moved among the descendents of @container
+ *
+ * Hooks up an adjustment to focus handling in @box. The
+ * adjustment is also used for autoscrolling during
+ * rubberband selection. See gtk_scrolled_window_get_hadjustment()
+ * for a typical way of obtaining the adjustment, and
+ * gtk_flow_box_set_vadjustment()for setting the vertical
+ * adjustment.
+ *
+ * The adjustments have to be in pixel units and in the same
+ * coordinate system as the allocation for immediate children
+ * of the box.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_hadjustment (GtkFlowBox    *box,
+                              GtkAdjustment *adjustment)
+{
+  GtkFlowBoxPrivate *priv;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+  g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+
+  priv = BOX_PRIV (box);
+
+  g_object_ref (adjustment);
+  if (priv->hadjustment)
+    g_object_unref (priv->hadjustment);
+  priv->hadjustment = adjustment;
+  gtk_container_set_focus_hadjustment (GTK_CONTAINER (box), adjustment);
+}
+
+/**
+ * gtk_flow_box_set_vadjustment:
+ * @box: a #GtkFlowBox
+ * @adjustment: an adjustment which should be adjusted
+ *    when the focus is moved among the descendents of @container
+ *
+ * Hooks up an adjustment to focus handling in @box. The
+ * adjustment is also used for autoscrolling during
+ * rubberband selection. See gtk_scrolled_window_get_vadjustment()
+ * for a typical way of obtaining the adjustment, and
+ * gtk_flow_box_set_hadjustment()for setting the horizontal
+ * adjustment.
+ *
+ * The adjustments have to be in pixel units and in the same
+ * coordinate system as the allocation for immediate children
+ * of the box.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_vadjustment (GtkFlowBox    *box,
+                              GtkAdjustment *adjustment)
+{
+  GtkFlowBoxPrivate *priv;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+  g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+
+  priv = BOX_PRIV (box);
+
+  g_object_ref (adjustment);
+  if (priv->vadjustment)
+    g_object_unref (priv->vadjustment);
+  priv->vadjustment = adjustment;
+  gtk_container_set_focus_vadjustment (GTK_CONTAINER (box), adjustment);
+}
+
+/* Setters and getters {{{2 */
+
+/**
+ * gtk_flow_box_get_homogeneous:
+ * @box: a #GtkFlowBox
+ *
+ * Returns whether the box is homogeneous (all children are the
+ * same size). See gtk_box_set_homogeneous().
+ *
+ * Return value: %TRUE if the box is homogeneous.
+ *
+ * Since: 3.12
+ */
+gboolean
+gtk_flow_box_get_homogeneous (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), FALSE);
+
+  return BOX_PRIV (box)->homogeneous;
+}
+
+/**
+ * gtk_flow_box_set_homogeneous:
+ * @box: a #GtkFlowBox
+ * @homogeneous: %TRUE to create equal allotments,
+ *   %FALSE for variable allotments
+ *
+ * Sets the #GtkFlowBox:homogeneous property of @box, controlling
+ * whether or not all children of @box are given equal space
+ * in the box.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_homogeneous (GtkFlowBox *box,
+                              gboolean    homogeneous)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  homogeneous = homogeneous != FALSE;
+
+  if (BOX_PRIV (box)->homogeneous != homogeneous)
+    {
+      BOX_PRIV (box)->homogeneous = homogeneous;
+
+      g_object_notify (G_OBJECT (box), "homogeneous");
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+    }
+}
+
+/**
+ * gtk_flow_box_set_row_spacing:
+ * @box: a #GtkFlowBox
+ * @spacing: the spacing to use
+ *
+ * Sets the vertical space to add between children.
+ * See the #GtkFlowBox:row-spacing property.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_row_spacing (GtkFlowBox *box,
+                              guint       spacing)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->row_spacing != spacing)
+    {
+      BOX_PRIV (box)->row_spacing = spacing;
+
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+      g_object_notify (G_OBJECT (box), "row-spacing");
+    }
+}
+
+/**
+ * gtk_flow_box_get_row_spacing:
+ * @box: a #GtkFlowBox
+ *
+ * Gets the vertical spacing.
+ *
+ * Returns: the vertical spacing
+ *
+ * Since: 3.12
+ */
+guint
+gtk_flow_box_get_row_spacing (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), FALSE);
+
+  return BOX_PRIV (box)->row_spacing;
+}
+
+/**
+ * gtk_flow_box_set_column_spacing:
+ * @box: a #GtkFlowBox
+ * @spacing: the spacing to use
+ *
+ * Sets the horizontal space to add between children.
+ * See the #GtkFlowBox:column-spacing property.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_column_spacing (GtkFlowBox *box,
+                                 guint       spacing)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->column_spacing != spacing)
+    {
+      BOX_PRIV (box)->column_spacing = spacing;
+
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+      g_object_notify (G_OBJECT (box), "column-spacing");
+    }
+}
+
+/**
+ * gtk_flow_box_get_column_spacing:
+ * @box: a #GtkFlowBox
+ *
+ * Gets the horizontal spacing.
+ *
+ * Returns: the horizontal spacing
+ *
+ * Since: 3.12
+ */
+guint
+gtk_flow_box_get_column_spacing (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), FALSE);
+
+  return BOX_PRIV (box)->column_spacing;
+}
+
+/**
+ * gtk_flow_box_set_min_children_per_line:
+ * @box: a #GtkFlowBox
+ * @n_children: the minimum number of children per line
+ *
+ * Sets the minimum number of children to line up
+ * in @box's orientation before flowing.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_min_children_per_line (GtkFlowBox *box,
+                                        guint       n_children)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->min_children_per_line != n_children)
+    {
+      BOX_PRIV (box)->min_children_per_line = n_children;
+
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+      g_object_notify (G_OBJECT (box), "min-children-per-line");
+    }
+}
+
+/**
+ * gtk_flow_box_get_min_children_per_line:
+ * @box: a #GtkFlowBox
+ *
+ * Gets the minimum number of children per line.
+ *
+ * Returns: the minimum number of children per line
+ *
+ * Since: 3.12
+ */
+guint
+gtk_flow_box_get_min_children_per_line (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), FALSE);
+
+  return BOX_PRIV (box)->min_children_per_line;
+}
+
+/**
+ * gtk_flow_box_set_max_children_per_line:
+ * @box: a #GtkFlowBox
+ * @n_children: the maximum number of children per line
+ *
+ * Sets the maximum number of children to request and
+ * allocate space for in @box's orientation.
+ *
+ * Setting the maximum number of children per line
+ * limits the overall natural size request to be no more
+ * than @n_children children long in the given orientation.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_max_children_per_line (GtkFlowBox *box,
+                                        guint       n_children)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->max_children_per_line != n_children)
+    {
+      BOX_PRIV (box)->max_children_per_line = n_children;
+
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+      g_object_notify (G_OBJECT (box), "max-children-per-line");
+    }
+}
+
+/**
+ * gtk_flow_box_get_max_children_per_line:
+ * @box: a #GtkFlowBox
+ *
+ * Gets the maximum number of children per line.
+ *
+ * Returns: the maximum number of children per line
+ *
+ * Since: 3.12
+ */
+guint
+gtk_flow_box_get_max_children_per_line (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), FALSE);
+
+  return BOX_PRIV (box)->max_children_per_line;
+}
+
+/**
+ * gtk_flow_box_set_activate_on_single_click:
+ * @box: a #GtkFlowBox
+ * @single: %TRUE to emit child-activated on a single click
+ *
+ * If @single is %TRUE, children will be activated when you click
+ * on them, otherwise you need to double-click.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_activate_on_single_click (GtkFlowBox *box,
+                                           gboolean    single)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  single = single != FALSE;
+
+  if (BOX_PRIV (box)->activate_on_single_click != single)
+    {
+      BOX_PRIV (box)->activate_on_single_click = single;
+      g_object_notify (G_OBJECT (box), "activate-on-single-click");
+    }
+}
+
+/**
+ * gtk_flow_box_get_activate_on_single_click:
+ * @box: a #GtkFlowBox
+ *
+ * Returns whether children activate on single clicks.
+ *
+ * Returns: %TRUE if children are activated on single click,
+ *     %FALSE otherwise
+ *
+ * Since: 3.12
+ */
+gboolean
+gtk_flow_box_get_activate_on_single_click (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), FALSE);
+
+  return BOX_PRIV (box)->activate_on_single_click;
+}
+
+/* Selection handling {{{2 */
+
+/**
+ * gtk_flow_box_get_selected_children:
+ * @box: a #GtkFlowBox
+ *
+ * Creates a list of all selected children.
+ *
+ * Returns: (element-type GtkFlowBoxChild) (transfer container):
+ *     A #GList containing the #GtkWidget for each selected child.
+ *     Free with g_list_free() when done.
+ *
+ * Since: 3.12
+ */
+GList *
+gtk_flow_box_get_selected_children (GtkFlowBox *box)
+{
+  GtkFlowBoxChild *child;
+  GSequenceIter *iter;
+  GList *selected = NULL;
+
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), NULL);
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      child = g_sequence_get (iter);
+      if (CHILD_PRIV (child)->selected)
+        selected = g_list_prepend (selected, child);
+    }
+
+  return g_list_reverse (selected);
+}
+
+/**
+ * gtk_flow_box_select_child:
+ * @box: a #GtkFlowBox
+ * @child: a child of @box
+ *
+ * Selects a single child of @box, if the selection
+ * mode allows it.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_select_child (GtkFlowBox      *box,
+                           GtkFlowBoxChild *child)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+  g_return_if_fail (GTK_IS_FLOW_BOX_CHILD (child));
+
+  gtk_flow_box_select_child_info (box, child);
+}
+
+/**
+ * gtk_flow_box_unselect_child:
+ * @box: a #GtkFlowBox
+ * @child: a child of @box
+ *
+ * Unselects a single child of @box, if the selection
+ * mode allows it.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_unselect_child (GtkFlowBox      *box,
+                             GtkFlowBoxChild *child)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+  g_return_if_fail (GTK_IS_FLOW_BOX_CHILD (child));
+
+  gtk_flow_box_unselect_child_info (box, child);
+}
+
+/**
+ * gtk_flow_box_select_all:
+ * @box: a #GtkFlowBox
+ *
+ * Select all children of @box, if the selection
+ * mode allows it.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_select_all (GtkFlowBox *box)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->selection_mode != GTK_SELECTION_MULTIPLE)
+    return;
+
+  if (g_sequence_get_length (BOX_PRIV (box)->children) > 0)
+    {
+      gtk_flow_box_select_all_between (box, NULL, NULL);
+      g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+    }
+}
+
+/**
+ * gtk_flow_box_unselect_all:
+ * @box: a #GtkFlowBox
+ *
+ * Unselect all children of @box, if the selection
+ * mode allows it.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_unselect_all (GtkFlowBox *box)
+{
+  gboolean dirty = FALSE;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->selection_mode == GTK_SELECTION_BROWSE)
+    return;
+
+  dirty = gtk_flow_box_unselect_all_internal (box);
+
+  if (dirty)
+    g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+}
+
+/**
+ * GtkFlowBoxForeachFunc:
+ * @box: a #GtkFlowBox
+ * @child: a #GtkFlowBoxChild
+ * @user_data: (closure): user data
+ *
+ * A function used by gtk_flow_box_selected_foreach().
+ * It will be called on every selected child of tht @box.
+ *
+ * Since: 3.12
+ */
+
+/**
+ * gtk_flow_box_selected_foreach:
+ * @box: a #GtkFlowBox
+ * @func: (scope call): the function to call for each selected child
+ * @data: user data to pass to the function
+ *
+ * Calls a function for each selected child.
+ *
+ * Note that the selection cannot be modified from within
+ * this function.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_selected_foreach (GtkFlowBox            *box,
+                               GtkFlowBoxForeachFunc  func,
+                               gpointer               data)
+{
+  GtkFlowBoxChild *child;
+  GSequenceIter *iter;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+       !g_sequence_iter_is_end (iter);
+       iter = g_sequence_iter_next (iter))
+    {
+      child = g_sequence_get (iter);
+      if (CHILD_PRIV (child)->selected)
+        (*func) (box, child, data);
+    }
+}
+
+/**
+ * gtk_flow_box_set_selection_mode:
+ * @box: a #GtkFlowBox
+ * @mode: the new selection mode
+ *
+ * Sets how selection works in @box.
+ * See #GtkSelectionMode for details.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_selection_mode (GtkFlowBox       *box,
+                                 GtkSelectionMode  mode)
+{
+  gboolean dirty = FALSE;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (mode == BOX_PRIV (box)->selection_mode)
+    return;
+
+  if (mode == GTK_SELECTION_NONE ||
+      BOX_PRIV (box)->selection_mode == GTK_SELECTION_MULTIPLE)
+    {
+      dirty = gtk_flow_box_unselect_all_internal (box);
+      BOX_PRIV (box)->selected_child = NULL;
+    }
+
+  BOX_PRIV (box)->selection_mode = mode;
+
+  g_object_notify (G_OBJECT (box), "selection-mode");
+
+  if (dirty)
+    g_signal_emit (box, signals[SELECTED_CHILDREN_CHANGED], 0);
+}
+
+/**
+ * gtk_flow_box_get_selection_mode:
+ * @box: a #GtkFlowBox
+ *
+ * Gets the selection mode of @box.
+ *
+ * Returns: the #GtkSelectionMode
+ *
+ * Since: 3.12
+ */
+GtkSelectionMode
+gtk_flow_box_get_selection_mode (GtkFlowBox *box)
+{
+  g_return_val_if_fail (GTK_IS_FLOW_BOX (box), GTK_SELECTION_SINGLE);
+
+  return BOX_PRIV (box)->selection_mode;
+}
+
+/* Filtering {{{2 */
+
+/**
+ * GtkFlowBoxFilterFunc:
+ * @child: a #GtkFlowBoxChild that may be filtered
+ * @user_data: (closure): user data
+ *
+ * A function that will be called whenrever a child changes
+ * or is added. It lets you control if the child should be
+ * visible or not.
+ *
+ * Returns: %TRUE if the row should be visible, %FALSE otherwise
+ *
+ * Since: 3.12
+ */
+
+/**
+ * gtk_flow_box_set_filter_func:
+ * @box: a #GtkFlowBox
+ * @filter_func: (closure user_data) (allow-none): callback that
+ *     lets you filter which children to show
+ * @user_data: user data passed to @filter_func
+ * @destroy: destroy notifier for @user_data
+ *
+ * By setting a filter function on the @box one can decide dynamically
+ * which of the children to show. For instance, to implement a search
+ * function that only shows the children matching the search terms.
+ *
+ * The @filter_func will be called for ach child after the call, and
+ * it will continue to be called each time a child changes (via
+ * gtk_flow_box_child_changed()) or when gtk_flow_box_invalidate_filter()
+ * is called.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_filter_func (GtkFlowBox           *box,
+                              GtkFlowBoxFilterFunc  filter_func,
+                              gpointer              user_data,
+                              GDestroyNotify        destroy)
+{
+  GtkFlowBoxPrivate *priv;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  priv = BOX_PRIV (box);
+
+  if (priv->filter_destroy != NULL)
+    priv->filter_destroy (priv->filter_data);
+
+  priv->filter_func = filter_func;
+  priv->filter_data = user_data;
+  priv->filter_destroy = destroy;
+
+  gtk_flow_box_invalidate_filter (box);
+}
+
+/**
+ * gtk_flow_box_invalidate_filter:
+ * @box: a #GtkFlowBox
+ *
+ * Updates the filtering for all children.
+ *
+ * Call this function when the result of the filter
+ * function on the @box is changed due ot an external
+ * factor. For instance, this would be used if the
+ * filter function just looked for a specific search
+ * term, and the entry with the string has changed.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_invalidate_filter (GtkFlowBox *box)
+{
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  if (BOX_PRIV (box)->filter_func != NULL)
+    {
+      GSequenceIter *iter;
+
+      for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
+           !g_sequence_iter_is_end (iter);
+           iter = g_sequence_iter_next (iter))
+        {
+          GtkFlowBoxChild *child;
+
+          child = g_sequence_get (iter);
+          gtk_flow_box_apply_filter (box, child);
+        }
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+    }
+}
+
+/* Sorting {{{2 */
+
+/**
+ * GtkFlowBoxSortFunc:
+ * @child1: the first child
+ * @child2: the second child
+ * @user_data: (closure): user data
+ *
+ * A function to compare two children to determine which
+ * should come first.
+ *
+ * Returns: < 0 if @child1 should be before @child2, 0 if
+ *     the are equal, and > 0 otherwise
+ *
+ * Since: 3.12
+ */
+
+/**
+ * gtk_flow_box_set_sort_func:
+ * @box: a #GtkFlowBox
+ * @sort_func: (closure user_data) (allow-none): the sort function
+ * @user_data: user data passed to @sort_func
+ * @destroy: destroy notifier for @user_data
+ *
+ * By setting a sort function on the @box, one can dynamically
+ * reorder the children of the box, based on the contents of
+ * the children.
+ *
+ * The @sort_func will be called for each child after the call,
+ * and will continue to be called each time a child changes (via
+ * gtk_flow_box_child_changed()) and when gtk_flow_box_invalidate_sort()
+ * is called.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_set_sort_func (GtkFlowBox         *box,
+                            GtkFlowBoxSortFunc  sort_func,
+                            gpointer            user_data,
+                            GDestroyNotify      destroy)
+{
+  GtkFlowBoxPrivate *priv;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  priv = BOX_PRIV (box);
+
+  if (priv->sort_destroy != NULL)
+    priv->sort_destroy (priv->sort_data);
+
+  priv->sort_func = sort_func;
+  priv->sort_data = user_data;
+  priv->sort_destroy = destroy;
+
+  gtk_flow_box_invalidate_sort (box);
+}
+
+static gint
+gtk_flow_box_sort (GtkFlowBoxChild *a,
+                   GtkFlowBoxChild *b,
+                   GtkFlowBox      *box)
+{
+  GtkFlowBoxPrivate *priv = BOX_PRIV (box);
+
+  return priv->sort_func (a, b, priv->sort_data);
+}
+
+/**
+ * gtk_flow_box_invalidate_sort:
+ * @box: a #GtkFlowBox
+ *
+ * Updates the sorting for all children.
+ *
+ * Call this when the result of the sort function on
+ * @box is changed due to an external factor.
+ *
+ * Since: 3.12
+ */
+void
+gtk_flow_box_invalidate_sort (GtkFlowBox *box)
+{
+  GtkFlowBoxPrivate *priv;
+
+  g_return_if_fail (GTK_IS_FLOW_BOX (box));
+
+  priv = BOX_PRIV (box);
+
+  if (priv->sort_func != NULL)
+    {
+      g_sequence_sort (priv->children,
+                       (GCompareDataFunc)gtk_flow_box_sort, box);
+      gtk_widget_queue_resize (GTK_WIDGET (box));
+    }
+}
+
+/* vim:set foldmethod=marker: */
diff --git a/gtk/gtkflowbox.h b/gtk/gtkflowbox.h
new file mode 100644
index 0000000..7989706
--- /dev/null
+++ b/gtk/gtkflowbox.h
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2010 Openismus GmbH
+ * Copyright (C) 2013 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Authors:
+ *      Tristan Van Berkom <tristanvb openismus com>
+ *      Matthias Clasen <mclasen redhat com>
+ *      William Jon McCann <jmccann redhat com>
+ */
+
+#ifndef __GTK_FLOW_BOX_H__
+#define __GTK_FLOW_BOX_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkbin.h>
+
+G_BEGIN_DECLS
+
+
+#define GTK_TYPE_FLOW_BOX                  (gtk_flow_box_get_type ())
+#define GTK_FLOW_BOX(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FLOW_BOX, 
GtkFlowBox))
+#define GTK_FLOW_BOX_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FLOW_BOX, 
GtkFlowBoxClass))
+#define GTK_IS_FLOW_BOX(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FLOW_BOX))
+#define GTK_IS_FLOW_BOX_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FLOW_BOX))
+#define GTK_FLOW_BOX_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FLOW_BOX, 
GtkFlowBoxClass))
+
+typedef struct _GtkFlowBox            GtkFlowBox;
+typedef struct _GtkFlowBoxClass       GtkFlowBoxClass;
+
+typedef struct _GtkFlowBoxChild       GtkFlowBoxChild;
+typedef struct _GtkFlowBoxChildClass  GtkFlowBoxChildClass;
+
+struct _GtkFlowBox
+{
+  GtkContainer container;
+};
+
+struct _GtkFlowBoxClass
+{
+  GtkContainerClass parent_class;
+
+  void (*child_activated)            (GtkFlowBox        *box,
+                                      GtkFlowBoxChild   *child);
+  void (*selected_children_changed)  (GtkFlowBox        *box);
+  void (*activate_cursor_child)      (GtkFlowBox        *box);
+  void (*toggle_cursor_child)        (GtkFlowBox        *box);
+  void (*move_cursor)                (GtkFlowBox        *box,
+                                      GtkMovementStep    step,
+                                      gint               count);
+  void (*select_all)                 (GtkFlowBox        *box);
+  void (*unselect_all)               (GtkFlowBox        *box);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+  void (*_gtk_reserved3) (void);
+  void (*_gtk_reserved4) (void);
+  void (*_gtk_reserved5) (void);
+  void (*_gtk_reserved6) (void);
+};
+
+#define GTK_TYPE_FLOW_BOX_CHILD            (gtk_flow_box_child_get_type ())
+#define GTK_FLOW_BOX_CHILD(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FLOW_BOX_CHILD, 
GtkFlowBoxChild))
+#define GTK_FLOW_BOX_CHILD_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FLOW_BOX_CHILD, 
GtkFlowBoxChildClass))
+#define GTK_IS_FLOW_BOX_CHILD(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FLOW_BOX_CHILD))
+#define GTK_IS_FLOW_BOX_CHILD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FLOW_BOX_CHILD))
+#define GTK_FLOW_BOX_CHILD_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EG_TYPE_FLOW_BOX_CHILD, 
GtkFlowBoxChildClass))
+
+struct _GtkFlowBoxChild
+{
+  GtkBin parent_instance;
+};
+
+struct _GtkFlowBoxChildClass
+{
+  GtkBinClass parent_class;
+
+  void (* activate) (GtkFlowBoxChild *child);
+
+  /* Padding for future expansion */
+  void (*_gtk_reserved1) (void);
+  void (*_gtk_reserved2) (void);
+};
+
+GDK_AVAILABLE_IN_3_12
+GType                 gtk_flow_box_child_get_type            (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_3_12
+GtkWidget*            gtk_flow_box_child_new                 (void);
+GDK_AVAILABLE_IN_3_12
+gint                  gtk_flow_box_child_get_index           (GtkFlowBoxChild *child);
+GDK_AVAILABLE_IN_3_12
+gboolean              gtk_flow_box_child_is_selected         (GtkFlowBoxChild *child);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_child_changed             (GtkFlowBoxChild *child);
+
+
+GDK_AVAILABLE_IN_3_12
+GType                 gtk_flow_box_get_type                  (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_3_12
+GtkWidget            *gtk_flow_box_new                       (void);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_homogeneous           (GtkFlowBox           *box,
+                                                              gboolean              homogeneous);
+GDK_AVAILABLE_IN_3_12
+gboolean              gtk_flow_box_get_homogeneous           (GtkFlowBox           *box);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_row_spacing           (GtkFlowBox           *box,
+                                                              guint                 spacing);
+GDK_AVAILABLE_IN_3_12
+guint                 gtk_flow_box_get_row_spacing           (GtkFlowBox           *box);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_column_spacing        (GtkFlowBox           *box,
+                                                              guint                 spacing);
+GDK_AVAILABLE_IN_3_12
+guint                 gtk_flow_box_get_column_spacing        (GtkFlowBox           *box);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_min_children_per_line (GtkFlowBox           *box,
+                                                              guint                 n_children);
+GDK_AVAILABLE_IN_3_12
+guint                 gtk_flow_box_get_min_children_per_line (GtkFlowBox           *box);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_max_children_per_line (GtkFlowBox           *box,
+                                                              guint                 n_children);
+GDK_AVAILABLE_IN_3_12
+guint                 gtk_flow_box_get_max_children_per_line (GtkFlowBox           *box);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_activate_on_single_click (GtkFlowBox        *box,
+                                                                 gboolean           single);
+GDK_AVAILABLE_IN_3_12
+gboolean              gtk_flow_box_get_activate_on_single_click (GtkFlowBox        *box);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_insert                       (GtkFlowBox        *box,
+                                                                 GtkWidget         *widget,
+                                                                 gint               position);
+GDK_AVAILABLE_IN_3_12
+GtkFlowBoxChild      *gtk_flow_box_get_child_at_index           (GtkFlowBox        *box,
+                                                                 gint               idx);
+
+typedef void (* GtkFlowBoxForeachFunc) (GtkFlowBox      *box,
+                                        GtkFlowBoxChild *child,
+                                        gpointer         user_data);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_selected_foreach             (GtkFlowBox        *box,
+                                                                 GtkFlowBoxForeachFunc func,
+                                                                 gpointer           data);
+GDK_AVAILABLE_IN_3_12
+GList                *gtk_flow_box_get_selected_children        (GtkFlowBox        *box);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_select_child                 (GtkFlowBox        *box,
+                                                                 GtkFlowBoxChild   *child);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_unselect_child               (GtkFlowBox        *box,
+                                                                 GtkFlowBoxChild   *child);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_select_all                   (GtkFlowBox        *box);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_unselect_all                 (GtkFlowBox        *box);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_selection_mode           (GtkFlowBox        *box,
+                                                                 GtkSelectionMode   mode);
+GDK_AVAILABLE_IN_3_12
+GtkSelectionMode      gtk_flow_box_get_selection_mode           (GtkFlowBox        *box);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_hadjustment              (GtkFlowBox        *box,
+                                                                 GtkAdjustment     *adjustment);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_vadjustment              (GtkFlowBox        *box,
+                                                                 GtkAdjustment     *adjustment);
+
+typedef gboolean (*GtkFlowBoxFilterFunc) (GtkFlowBoxChild *child,
+                                          gpointer         user_data);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_filter_func              (GtkFlowBox        *box,
+                                                                 GtkFlowBoxFilterFunc filter_func,
+                                                                 gpointer             user_data,
+                                                                 GDestroyNotify       destroy);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_invalidate_filter            (GtkFlowBox        *box);
+
+typedef gint (*GtkFlowBoxSortFunc) (GtkFlowBoxChild *child1,
+                                    GtkFlowBoxChild *child2,
+                                    gpointer         user_data);
+
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_set_sort_func                (GtkFlowBox        *box,
+                                                                 GtkFlowBoxSortFunc  sort_func,
+                                                                 gpointer            user_data,
+                                                                 GDestroyNotify      destroy);
+GDK_AVAILABLE_IN_3_12
+void                  gtk_flow_box_invalidate_sort              (GtkFlowBox         *box);
+
+G_END_DECLS
+
+
+#endif /* __GTK_FLOW_BOX_H__ */
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 5478b9f..e513f40 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -54,6 +54,7 @@ noinst_PROGRAMS =  $(TEST_PROGS)      \
        testentryicons                  \
        testfilechooser                 \
        testfilechooserbutton           \
+       testflowbox                     \
        testfontselection               \
        testfontselectiondialog         \
        testfontchooser                 \
@@ -190,6 +191,7 @@ testentryicons_DEPENDENCIES = $(TEST_DEPS)
 testerrors_DEPENDENCIES = $(TEST_DEPS)
 testfilechooser_DEPENDENCIES = $(TEST_DEPS)
 testfilechooserbutton_DEPENDENCIES = $(TEST_DEPS)
+testflowbox_DEPENDENCIES = $(TEST_DEPS)
 testfontselection_DEPENDENCIES = $(TEST_DEPS)
 testfontselectiondialog_DEPENDENCIES = $(TEST_DEPS)
 testfontchooser_DEPENDENCIES = $(TEST_DEPS)
@@ -310,6 +312,9 @@ testfilechooserbutton_SOURCES =     \
        prop-editor.c           \
        testfilechooserbutton.c
 
+testflowbox_SOURCES = \
+       testflowbox.c
+
 testfontselection_SOURCES = \
        testfontselection.c
 
diff --git a/tests/testflowbox.c b/tests/testflowbox.c
new file mode 100644
index 0000000..522231b
--- /dev/null
+++ b/tests/testflowbox.c
@@ -0,0 +1,692 @@
+/*
+ * Copyright (C) 2010 Openismus GmbH
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gtk/gtk.h>
+
+enum {
+  SIMPLE_ITEMS = 0,
+  FOCUS_ITEMS,
+  WRAPPY_ITEMS,
+  STOCK_ITEMS,
+  IMAGE_ITEMS
+};
+
+#define INITIAL_HALIGN          GTK_ALIGN_FILL
+#define INITIAL_VALIGN          GTK_ALIGN_START
+#define INITIAL_MINIMUM_LENGTH  3
+#define INITIAL_MAXIMUM_LENGTH  6
+#define INITIAL_CSPACING        2
+#define INITIAL_RSPACING        2
+#define N_ITEMS 1000
+
+static GtkFlowBox    *the_flowbox       = NULL;
+static gint           items_type       = SIMPLE_ITEMS;
+static GtkOrientation text_orientation = GTK_ORIENTATION_HORIZONTAL;
+
+static void
+populate_flowbox_simple (GtkFlowBox *flowbox)
+{
+  GtkWidget *widget, *frame;
+  gint i;
+
+  for (i = 0; i < N_ITEMS; i++)
+    {
+      gchar *text = g_strdup_printf ("Item %02d", i);
+
+      widget = gtk_label_new (text);
+      frame  = gtk_frame_new (NULL);
+      gtk_widget_show (widget);
+      gtk_widget_show (frame);
+
+      gtk_container_add (GTK_CONTAINER (frame), widget);
+
+      if (text_orientation == GTK_ORIENTATION_VERTICAL)
+        gtk_label_set_angle (GTK_LABEL (widget), 90);
+      g_object_set_data_full (G_OBJECT (frame), "id", (gpointer)g_strdup (text), g_free);
+      gtk_container_add (GTK_CONTAINER (flowbox), frame);
+
+      g_free (text);
+    }
+}
+
+static void
+populate_flowbox_focus (GtkFlowBox *flowbox)
+{
+  GtkWidget *widget, *frame, *box;
+  gint i;
+  gboolean sensitive;
+
+  for (i = 0; i < 200; i++)
+    {
+      sensitive = TRUE;
+      frame = gtk_frame_new (NULL);
+
+      box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+      gtk_container_add (GTK_CONTAINER (frame), box);
+
+      widget = gtk_label_new ("Label");
+      gtk_container_add (GTK_CONTAINER (box), widget);
+
+      switch (i % 4)
+        {
+        case 0:
+          widget = gtk_entry_new ();
+          break;
+        case 1:
+          widget = gtk_button_new_with_label ("Button");
+          break;
+        case 2:
+          widget = gtk_label_new ("bla");
+          break;
+        case 3:
+          widget = gtk_label_new ("bla");
+          sensitive = FALSE;
+          break;
+        }
+
+      gtk_container_add (GTK_CONTAINER (box), widget);
+
+      if (i % 5 == 0)
+        gtk_container_add (GTK_CONTAINER (box), gtk_switch_new ());
+
+      gtk_widget_show_all (frame);
+
+      gtk_container_add (GTK_CONTAINER (flowbox), frame);
+      if (!sensitive)
+        gtk_widget_set_sensitive (gtk_widget_get_parent (frame), FALSE);
+    }
+}
+
+static void
+populate_flowbox_wrappy (GtkFlowBox *flowbox)
+{
+  GtkWidget *widget, *frame;
+  gint i;
+
+  const gchar *strings[] = {
+    "These are", "some wrappy label", "texts", "of various", "lengths.",
+    "They should always be", "shown", "consecutively. Except it's",
+    "hard to say", "where exactly the", "label", "will wrap", "and where exactly",
+    "the actual", "container", "will wrap.", "This label is really really really long !",
+    "Let's add some more", "labels to the",
+    "mix. Just to", "make sure we", "got something to work", "with here."
+  };
+
+  for (i = 0; i < G_N_ELEMENTS (strings); i++)
+    {
+      widget = gtk_label_new (strings[i]);
+      frame  = gtk_frame_new (NULL);
+      gtk_widget_show (widget);
+      gtk_widget_show (frame);
+
+      if (text_orientation == GTK_ORIENTATION_VERTICAL)
+        gtk_label_set_angle (GTK_LABEL (widget), 90);
+
+      gtk_container_add (GTK_CONTAINER (frame), widget);
+
+      gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
+      gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
+      gtk_label_set_width_chars (GTK_LABEL (widget), 10);
+      g_object_set_data_full (G_OBJECT (frame), "id", (gpointer)g_strdup (strings[i]), g_free);
+
+      gtk_container_add (GTK_CONTAINER (flowbox), frame);
+    }
+}
+
+static void
+populate_flowbox_stock (GtkFlowBox *flowbox)
+{
+  GtkWidget *widget;
+  static GSList *stock_ids = NULL;
+  GSList *l;
+  gint i;
+
+  if (!stock_ids)
+    stock_ids = gtk_stock_list_ids ();
+
+  for (i = 0, l = stock_ids; i < 30 && l != NULL; i++, l = l->next)
+    {
+      gchar *stock_id = l->data;
+      gchar *text = g_strdup_printf ("Item %02d", i);
+
+      widget = gtk_button_new_from_stock (stock_id);
+      gtk_widget_show (widget);
+
+      g_object_set_data_full (G_OBJECT (widget), "id", (gpointer)g_strdup (text), g_free);
+      gtk_container_add (GTK_CONTAINER (flowbox), widget);
+    }
+}
+
+static void
+populate_flowbox_images (GtkFlowBox *flowbox)
+{
+  GtkWidget *widget, *image, *label;
+  gint i;
+
+  for (i = 0; i < N_ITEMS; i++)
+    {
+      gchar *text = g_strdup_printf ("Item %02d", i);
+
+      widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+      gtk_widget_set_hexpand (widget, TRUE);
+
+      image = gtk_image_new_from_icon_name ("face-wink", GTK_ICON_SIZE_DIALOG);
+      gtk_widget_set_hexpand (image, TRUE);
+      gtk_image_set_pixel_size (GTK_IMAGE (image), 256);
+
+      label = gtk_label_new (text);
+
+      gtk_container_add (GTK_CONTAINER (widget), image);
+      gtk_container_add (GTK_CONTAINER (widget), label);
+      gtk_widget_show_all (widget);
+
+      if (text_orientation == GTK_ORIENTATION_VERTICAL)
+        gtk_label_set_angle (GTK_LABEL (widget), 90);
+
+      g_object_set_data_full (G_OBJECT (widget), "id", (gpointer)g_strdup (text), g_free);
+      gtk_container_add (GTK_CONTAINER (flowbox), widget);
+
+      g_free (text);
+    }
+}
+
+static void
+populate_items (GtkFlowBox *flowbox)
+{
+  GList *children, *l;
+
+  /* Remove all children first */
+  children = gtk_container_get_children (GTK_CONTAINER (flowbox));
+  for (l = children; l; l = l->next)
+    {
+      GtkWidget *child = l->data;
+
+      gtk_container_remove (GTK_CONTAINER (flowbox), child);
+    }
+  g_list_free (children);
+
+  if (items_type == SIMPLE_ITEMS)
+    populate_flowbox_simple (flowbox);
+  else if (items_type == FOCUS_ITEMS)
+    populate_flowbox_focus (flowbox);
+  else if (items_type == WRAPPY_ITEMS)
+    populate_flowbox_wrappy (flowbox);
+  else if (items_type == STOCK_ITEMS)
+    populate_flowbox_stock (flowbox);
+  else if (items_type == IMAGE_ITEMS)
+    populate_flowbox_images (flowbox);
+}
+
+static void
+horizontal_alignment_changed (GtkComboBox   *box,
+                              GtkFlowBox    *flowbox)
+{
+  GtkAlign alignment = gtk_combo_box_get_active (box);
+
+  gtk_widget_set_halign (GTK_WIDGET (flowbox), alignment);
+}
+
+static void
+vertical_alignment_changed (GtkComboBox   *box,
+                            GtkFlowBox    *flowbox)
+{
+  GtkAlign alignment = gtk_combo_box_get_active (box);
+
+  gtk_widget_set_valign (GTK_WIDGET (flowbox), alignment);
+}
+
+static void
+orientation_changed (GtkComboBox   *box,
+                     GtkFlowBox *flowbox)
+{
+  GtkOrientation orientation = gtk_combo_box_get_active (box);
+
+  gtk_orientable_set_orientation (GTK_ORIENTABLE (flowbox), orientation);
+}
+
+static void
+selection_mode_changed (GtkComboBox *box,
+                        GtkFlowBox  *flowbox)
+{
+  GtkSelectionMode mode = gtk_combo_box_get_active (box);
+
+  gtk_flow_box_set_selection_mode (flowbox, mode);
+}
+
+static void
+line_length_changed (GtkSpinButton *spin,
+                     GtkFlowBox *flowbox)
+{
+  gint length = gtk_spin_button_get_value_as_int (spin);
+
+  gtk_flow_box_set_min_children_per_line (flowbox, length);
+}
+
+static void
+max_line_length_changed (GtkSpinButton *spin,
+                         GtkFlowBox *flowbox)
+{
+  gint length = gtk_spin_button_get_value_as_int (spin);
+
+  gtk_flow_box_set_max_children_per_line (flowbox, length);
+}
+
+static void
+spacing_changed (GtkSpinButton *button,
+                 gpointer       data)
+{
+  GtkOrientation orientation = GPOINTER_TO_INT (data);
+  gint           state = gtk_spin_button_get_value_as_int (button);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    gtk_flow_box_set_column_spacing (the_flowbox, state);
+  else
+    gtk_flow_box_set_row_spacing (the_flowbox, state);
+}
+
+static void
+items_changed (GtkComboBox   *box,
+               GtkFlowBox *flowbox)
+{
+  items_type = gtk_combo_box_get_active (box);
+
+  populate_items (flowbox);
+}
+
+static void
+text_orientation_changed (GtkComboBox   *box,
+                          GtkFlowBox *flowbox)
+{
+  text_orientation = gtk_combo_box_get_active (box);
+
+  populate_items (flowbox);
+}
+
+static void
+homogeneous_toggled (GtkToggleButton *button,
+                     GtkFlowBox      *flowbox)
+{
+  gboolean state = gtk_toggle_button_get_active (button);
+
+  gtk_flow_box_set_homogeneous (flowbox, state);
+}
+
+static void
+on_child_activated (GtkFlowBox *self,
+                    GtkWidget  *child)
+{
+  const char *id;
+  id = g_object_get_data (G_OBJECT (gtk_bin_get_child (GTK_BIN (child))), "id");
+  g_message ("Child activated %p: %s", child, id);
+}
+
+static void
+selection_foreach (GtkFlowBox      *self,
+                   GtkFlowBoxChild *child_info,
+                   gpointer         data)
+{
+  const char *id;
+  GtkWidget *child;
+
+  child = gtk_bin_get_child (GTK_BIN (child_info));
+  id = g_object_get_data (G_OBJECT (child), "id");
+  g_message ("Child selected %p: %s", child, id);
+}
+
+static void
+on_selected_children_changed (GtkFlowBox *self)
+{
+  g_message ("Selection changed");
+  //gtk_flow_box_selected_foreach (self, selection_foreach, NULL);
+}
+
+static gboolean
+filter_func (GtkFlowBoxChild *child, gpointer user_data)
+{
+  gint index;
+
+  index = gtk_flow_box_child_get_index (child);
+
+  return (index % 3) == 0;
+}
+
+static void
+filter_toggled (GtkToggleButton *button,
+                GtkFlowBox      *flowbox)
+{
+  gboolean state = gtk_toggle_button_get_active (button);
+
+  if (state)
+    gtk_flow_box_set_filter_func (flowbox, filter_func, NULL, NULL);
+  else
+    gtk_flow_box_set_filter_func (flowbox, NULL, NULL, NULL);
+}
+
+static gint
+sort_func (GtkFlowBoxChild *a,
+           GtkFlowBoxChild *b,
+           gpointer         data)
+{
+  gchar *ida, *idb;
+
+  ida = (gchar *)g_object_get_data (G_OBJECT (gtk_bin_get_child (GTK_BIN (a))), "id");
+  idb = (gchar *)g_object_get_data (G_OBJECT (gtk_bin_get_child (GTK_BIN (b))), "id");
+  return g_strcmp0 (ida, idb);
+}
+
+static void
+sort_toggled (GtkToggleButton *button,
+              GtkFlowBox      *flowbox)
+{
+  gboolean state = gtk_toggle_button_get_active (button);
+
+  if (state)
+    gtk_flow_box_set_sort_func (flowbox, sort_func, NULL, NULL);
+  else
+    gtk_flow_box_set_sort_func (flowbox, NULL, NULL, NULL);
+}
+
+static GtkWidget *
+create_window (void)
+{
+  GtkWidget *window, *hbox, *vbox, *flowbox_cntl, *items_cntl;
+  GtkWidget *flowbox, *widget, *expander, *swindow;
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  hbox   = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+  vbox   = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+
+  gtk_container_set_border_width (GTK_CONTAINER (window), 8);
+
+  gtk_widget_show (vbox);
+  gtk_widget_show (hbox);
+  gtk_container_add (GTK_CONTAINER (window), hbox);
+  gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
+
+  swindow = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
+                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+
+  gtk_widget_show (swindow);
+  gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0);
+
+  flowbox = gtk_flow_box_new ();
+  gtk_widget_set_halign (flowbox, GTK_ALIGN_END);
+  the_flowbox = (GtkFlowBox *)flowbox;
+  gtk_widget_set_halign (flowbox, INITIAL_HALIGN);
+  gtk_widget_set_valign (flowbox, INITIAL_VALIGN);
+  gtk_flow_box_set_column_spacing (GTK_FLOW_BOX (flowbox), INITIAL_CSPACING);
+  gtk_flow_box_set_row_spacing (GTK_FLOW_BOX (flowbox), INITIAL_RSPACING);
+  gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MINIMUM_LENGTH);
+  gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MAXIMUM_LENGTH);
+  gtk_widget_show (flowbox);
+  gtk_container_add (GTK_CONTAINER (swindow), flowbox);
+
+  gtk_flow_box_set_hadjustment (GTK_FLOW_BOX (flowbox),
+                                gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (swindow)));
+  gtk_flow_box_set_vadjustment (GTK_FLOW_BOX (flowbox),
+                                gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swindow)));
+
+  g_signal_connect (flowbox, "child-activated", G_CALLBACK (on_child_activated), NULL);
+  g_signal_connect (flowbox, "selected-children-changed", G_CALLBACK (on_selected_children_changed), NULL);
+
+  /* Add Flowbox test control frame */
+  expander = gtk_expander_new ("Flow Box controls");
+  gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
+  flowbox_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+  gtk_widget_show (flowbox_cntl);
+  gtk_widget_show (expander);
+  gtk_container_add (GTK_CONTAINER (expander), flowbox_cntl);
+  gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
+
+  widget = gtk_check_button_new_with_label ("Homogeneous");
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set whether the items should be displayed at the same size");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "toggled",
+                    G_CALLBACK (homogeneous_toggled), flowbox);
+
+  widget = gtk_check_button_new_with_label ("Activate on single click");
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
+  g_object_bind_property (widget, "active",
+                          flowbox, "activate-on-single-click",
+                          G_BINDING_SYNC_CREATE);
+  gtk_widget_show (widget);
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  /* Add alignment controls */
+  widget = gtk_combo_box_text_new ();
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
+  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_HALIGN);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the horizontal alignment policy");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (horizontal_alignment_changed), flowbox);
+
+  widget = gtk_combo_box_text_new ();
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
+  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_VALIGN);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the vertical alignment policy");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (vertical_alignment_changed), flowbox);
+
+  /* Add Orientation control */
+  widget = gtk_combo_box_text_new ();
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
+  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the flowbox orientation");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (orientation_changed), flowbox);
+
+  /* Add selection mode control */
+  widget = gtk_combo_box_text_new ();
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "None");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Single");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Browse");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Multiple");
+  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the selection mode");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (selection_mode_changed), flowbox);
+
+  /* Add minimum line length in items control */
+  widget = gtk_spin_button_new_with_range (1, 10, 1);
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (line_length_changed), flowbox);
+  g_signal_connect (G_OBJECT (widget), "value-changed",
+                    G_CALLBACK (line_length_changed), flowbox);
+
+  /* Add natural line length in items control */
+  widget = gtk_spin_button_new_with_range (1, 10, 1);
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MAXIMUM_LENGTH);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the natural amount of items per line ");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (max_line_length_changed), flowbox);
+  g_signal_connect (G_OBJECT (widget), "value-changed",
+                    G_CALLBACK (max_line_length_changed), flowbox);
+
+  /* Add horizontal/vertical spacing controls */
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+  gtk_widget_show (hbox);
+
+  widget = gtk_label_new ("H Spacing");
+  gtk_widget_show (widget);
+  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+
+  widget = gtk_spin_button_new_with_range (0, 30, 1);
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_CSPACING);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children");
+  gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
+  g_signal_connect (G_OBJECT (widget), "value-changed",
+                    G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
+
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+  gtk_widget_show (hbox);
+
+  widget = gtk_label_new ("V Spacing");
+  gtk_widget_show (widget);
+  gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+
+  widget = gtk_spin_button_new_with_range (0, 30, 1);
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_RSPACING);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children");
+  gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
+  g_signal_connect (G_OBJECT (widget), "value-changed",
+                    G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
+
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
+
+  /* filtering and sorting */
+
+  widget = gtk_check_button_new_with_label ("Filter");
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set whether some items should be filtered out");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "toggled",
+                    G_CALLBACK (filter_toggled), flowbox);
+
+  widget = gtk_check_button_new_with_label ("Sort");
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set whether items should be sorted");
+  gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "toggled",
+                    G_CALLBACK (sort_toggled), flowbox);
+
+
+  /* Add test items control frame */
+  expander = gtk_expander_new ("Test item controls");
+  gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
+  items_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+  gtk_widget_show (items_cntl);
+  gtk_widget_show (expander);
+  gtk_container_add (GTK_CONTAINER (expander), items_cntl);
+  gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
+
+  /* Add Items control */
+  widget = gtk_combo_box_text_new ();
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Simple");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Focus");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Wrappy");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Stock");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Images");
+  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the item set to use");
+  gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (items_changed), flowbox);
+
+
+  /* Add Text Orientation control */
+  widget = gtk_combo_box_text_new ();
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
+  gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
+  gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
+  gtk_widget_show (widget);
+
+  gtk_widget_set_tooltip_text (widget, "Set the item's text orientation (cant be done for stock buttons)");
+  gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
+
+  g_signal_connect (G_OBJECT (widget), "changed",
+                    G_CALLBACK (text_orientation_changed), flowbox);
+
+  populate_items (GTK_FLOW_BOX (flowbox));
+
+  /* This line was added only for the convenience of reproducing
+   * a height-for-width inside GtkScrolledWindow bug (bug 629778).
+   *   -Tristan
+   */
+  gtk_window_set_default_size (GTK_WINDOW (window), 390, -1);
+
+  return window;
+}
+
+int
+main (int argc, char *argv[])
+{
+  GtkWidget *window;
+
+  gtk_init (&argc, &argv);
+
+  window = create_window ();
+
+  g_signal_connect (window, "delete-event",
+                    G_CALLBACK (gtk_main_quit), window);
+
+  gtk_widget_show (window);
+
+  gtk_main ();
+
+  return 0;
+}


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]