[libgd/wip/rishi/main-box: 6/9] Add GdMainIconBox

[Debarshi Ray <debarshir src gnome org>]

commit d255def46fed48552bfebffe76f6f5d7b9b1bdb3
Author: Debarshi Ray <debarshir gnome org>
Date:   Wed Nov 23 16:46:50 2016 +0100

    Add GdMainIconBox
    
    https://bugzilla.gnome.org/show_bug.cgi?id=774914

 libgd/gd-main-icon-box.c | 1109 ++++++++++++++++++++++++++++++++++++++++++++++
 libgd/gd-main-icon-box.h |   44 ++
 2 files changed, 1153 insertions(+), 0 deletions(-)
---
diff --git a/libgd/gd-main-icon-box.c b/libgd/gd-main-icon-box.c
new file mode 100644
index 0000000..3e1d2dd
--- /dev/null
+++ b/libgd/gd-main-icon-box.c
@@ -0,0 +1,1109 @@
+/*
+ * Copyright (c) 2016 Red Hat, Inc.
+ *
+ * This program 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 program 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 program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author: Debarshi Ray <debarshir gnome org>
+ *
+ */
+
+#include <math.h>
+
+#include <cairo.h>
+#include <gio/gio.h>
+
+#include "gd-main-icon-box.h"
+#include "gd-main-icon-box-child.h"
+#include "gd-main-box-child.h"
+#include "gd-main-box-generic.h"
+#include "gd-main-box-item.h"
+
+#define MAIN_ICON_BOX_DND_ICON_OFFSET 20
+
+typedef struct _GdMainIconBoxPrivate GdMainIconBoxPrivate;
+
+struct _GdMainIconBoxPrivate
+{
+  GListModel *model;
+  gboolean dnd_started;
+  gboolean key_pressed;
+  gboolean key_shift_pressed;
+  gboolean left_button_released;
+  gboolean left_button_shift_released;
+  gboolean selection_changed;
+  gboolean selection_mode;
+  gchar *last_selected_id;
+  gdouble dnd_start_x;
+  gdouble dnd_start_y;
+  gint dnd_button;
+};
+
+enum
+{
+  PROP_LAST_SELECTED_ID = 1,
+  PROP_MODEL,
+  PROP_SELECTION_MODE,
+  NUM_PROPERTIES
+};
+
+static void gd_main_box_generic_interface_init (GdMainBoxGenericInterface *iface);
+G_DEFINE_TYPE_WITH_CODE (GdMainIconBox, gd_main_icon_box, GTK_TYPE_FLOW_BOX,
+                         G_ADD_PRIVATE (GdMainIconBox)
+                         G_IMPLEMENT_INTERFACE (GD_TYPE_MAIN_BOX_GENERIC, 
gd_main_box_generic_interface_init))
+
+static cairo_surface_t *
+create_surface_with_counter (GtkWidget *widget, cairo_surface_t *base, gint number)
+{
+  GtkStyleContext *context;
+  cairo_t *cr, *emblem_cr;
+  cairo_surface_t *emblem_surface;
+  cairo_surface_t *surface;
+  gint height;
+  gint height_scaled;
+  gint width;
+  gint width_scaled;
+  gint layout_width, layout_height;
+  gint emblem_size;
+  gint emblem_size_scaled;
+  gdouble scale;
+  gdouble scale_x;
+  gdouble scale_y;
+  gchar *str;
+  PangoLayout *layout;
+  PangoAttrList *attr_list;
+  PangoAttribute *attr;
+  PangoFontDescription *desc;
+  GdkRGBA color;
+
+  context = gtk_widget_get_style_context (GTK_WIDGET (widget));
+  gtk_style_context_save (context);
+  gtk_style_context_add_class (context, "documents-counter");
+
+  width_scaled = cairo_image_surface_get_width (base);
+  height_scaled = cairo_image_surface_get_height (base);
+  cairo_surface_get_device_scale (base, &scale_x, &scale_y);
+
+  width = width_scaled / (gint) floor (scale_x),
+  height = height_scaled / (gint) floor (scale_y);
+
+  surface = cairo_surface_create_similar_image (base, CAIRO_FORMAT_ARGB32,
+                                                width_scaled, height_scaled);
+  cairo_surface_set_device_scale (surface, scale_x, scale_y);
+
+  cr = cairo_create (surface);
+  cairo_set_source_surface (cr, base, 0, 0);
+  cairo_paint (cr);
+
+  emblem_size_scaled = MIN (width_scaled / 2, height_scaled / 2);
+  emblem_size = MIN (width / 2, height / 2);
+
+  emblem_surface = cairo_surface_create_similar_image (base, CAIRO_FORMAT_ARGB32,
+                                                       emblem_size_scaled, emblem_size_scaled);
+  cairo_surface_set_device_scale (emblem_surface, scale_x, scale_y);
+
+  emblem_cr = cairo_create (emblem_surface);
+  gtk_render_background (context, emblem_cr,
+                         0, 0, emblem_size, emblem_size);
+
+  if (number > 99)
+    number = 99;
+  if (number < -99)
+    number = -99;
+
+  str = g_strdup_printf ("%d", number);
+  layout = gtk_widget_create_pango_layout (GTK_WIDGET (widget), str);
+  g_free (str);
+
+  pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
+
+  /* scale the layout to be 0.5 of the size still available for drawing */
+  scale = (emblem_size * 0.50) / (MAX (layout_width, layout_height));
+  attr_list = pango_attr_list_new ();
+
+  attr = pango_attr_scale_new (scale);
+  pango_attr_list_insert (attr_list, attr);
+  pango_layout_set_attributes (layout, attr_list);
+
+  gtk_style_context_get (context, GTK_STATE_FLAG_NORMAL, "font", &desc, NULL);
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  gtk_style_context_get_color (context, 0, &color);
+  gdk_cairo_set_source_rgba (emblem_cr, &color);
+
+  /* update these values */
+  pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
+
+  cairo_move_to (emblem_cr,
+                 emblem_size / 2 - layout_width / 2,
+                 emblem_size / 2 - layout_height / 2);
+
+  pango_cairo_show_layout (emblem_cr, layout);
+
+  g_object_unref (layout);
+  pango_attr_list_unref (attr_list);
+  cairo_destroy (emblem_cr);
+
+  cairo_set_source_surface (cr, emblem_surface, 
+                            width - emblem_size, height - emblem_size);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+  cairo_surface_destroy (emblem_surface);
+  gtk_style_context_restore (context);
+
+  return surface;
+}
+
+static cairo_surface_t *
+copy_image_surface (cairo_surface_t *surface)
+{
+  cairo_surface_t *copy = NULL;
+  cairo_t *cr;
+  gdouble scale_x;
+  gdouble scale_y;
+
+  if (surface == NULL)
+    goto out;
+
+  copy = cairo_surface_create_similar_image (surface, CAIRO_FORMAT_ARGB32,
+                                             cairo_image_surface_get_width (surface),
+                                             cairo_image_surface_get_height (surface));
+  cairo_surface_get_device_scale (surface, &scale_x, &scale_y);
+  cairo_surface_set_device_scale (copy, scale_x, scale_y);
+
+  cr = cairo_create (copy);
+  cairo_set_source_surface (cr, surface, 0, 0);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+ out:
+  return copy;
+}
+
+static void
+gd_main_icon_box_update_last_selected_id (GdMainIconBox *self, GdMainBoxChild *child)
+{
+  GdMainIconBoxPrivate *priv;
+  GdMainBoxItem *item;
+  const gchar *id = NULL;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (child != NULL)
+    {
+      item = gd_main_box_child_get_item (child);
+      id = gd_main_box_item_get_id (item);
+    }
+
+  if (g_strcmp0 (priv->last_selected_id, id) != 0)
+    {
+      g_free (priv->last_selected_id);
+      priv->last_selected_id = g_strdup (id);
+      g_object_notify (G_OBJECT (self), "last-selected-id");
+    }
+}
+
+GtkWidget *
+gd_main_icon_box_create_widget_func (gpointer item, gpointer user_data)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (user_data);
+  GdMainIconBoxPrivate *priv;
+  GtkWidget *child;
+
+  g_return_val_if_fail (GD_IS_MAIN_BOX_ITEM (item), NULL);
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  child = gd_main_icon_box_child_new (GD_MAIN_BOX_ITEM (item), priv->selection_mode);
+  gtk_widget_show_all (child);
+
+  return child;
+}
+
+static GdMainBoxChild *
+gd_main_icon_box_get_child_at_index (GdMainBoxGeneric *generic, gint index)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  GdMainIconBoxPrivate *priv;
+  GtkFlowBoxChild *child;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  child = gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self), index);
+  return GD_MAIN_BOX_CHILD (child);
+}
+
+static const gchar *
+gd_main_icon_box_get_last_selected_id (GdMainBoxGeneric *generic)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+  return priv->last_selected_id;
+}
+
+static GListModel *
+gd_main_icon_box_get_model (GdMainIconBox *self)
+{
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+  return priv->model;
+}
+
+static GList *
+gd_main_icon_box_get_selected_children (GdMainBoxGeneric *generic)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  GdMainIconBoxPrivate *priv;
+  GList *selected_children;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  selected_children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (self));
+  return selected_children;
+}
+
+static gboolean
+gd_main_icon_box_get_selection_mode (GdMainIconBox *self)
+{
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+  return priv->selection_mode;
+}
+
+static void
+gd_main_icon_box_select_all_generic (GdMainBoxGeneric *generic)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  g_signal_emit_by_name (self, "select-all");
+}
+
+static void
+gd_main_icon_box_select_child (GdMainBoxGeneric *generic, GdMainBoxChild *child)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+  gtk_flow_box_select_child (GTK_FLOW_BOX (self), GTK_FLOW_BOX_CHILD (child));
+}
+
+static void
+gd_main_icon_box_set_model (GdMainIconBox *self, GListModel *model)
+{
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (!g_set_object (&priv->model, model))
+    return;
+
+  gtk_flow_box_bind_model (GTK_FLOW_BOX (self),
+                           priv->model,
+                           gd_main_icon_box_create_widget_func,
+                           self,
+                           NULL);
+
+  g_object_notify (G_OBJECT (self), "model");
+}
+
+static void
+gd_main_icon_box_set_selection_mode (GdMainIconBox *self, gboolean selection_mode)
+{
+  GdMainIconBoxPrivate *priv;
+  gint i;
+  gint n_items;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (priv->selection_mode == selection_mode)
+    return;
+
+  gd_main_icon_box_update_last_selected_id (self, NULL);
+
+  priv->selection_mode = selection_mode;
+  if (priv->selection_mode)
+    gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (self), GTK_SELECTION_MULTIPLE);
+  else
+    gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (self), GTK_SELECTION_NONE);
+
+  /* Work around https://bugzilla.gnome.org/show_bug.cgi?id=775525. */
+  n_items = (gint) g_list_model_get_n_items (G_LIST_MODEL (priv->model));
+  for (i = 0; i < n_items; i++)
+    {
+      GtkFlowBoxChild *child;
+
+      child = gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self), i);
+      gd_main_box_child_set_selection_mode (GD_MAIN_BOX_CHILD (child), priv->selection_mode);
+    }
+
+  g_object_notify (G_OBJECT (self), "last-selected-id");
+  g_object_notify (G_OBJECT (self), "selection-mode");
+}
+
+static void
+gd_main_icon_box_unselect_all_generic (GdMainBoxGeneric *generic)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  g_signal_emit_by_name (self, "unselect-all");
+}
+
+static void
+gd_main_icon_box_unselect_child (GdMainBoxGeneric *generic, GdMainBoxChild *child)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (generic);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+  gtk_flow_box_unselect_child (GTK_FLOW_BOX (self), GTK_FLOW_BOX_CHILD (child));
+}
+
+static void
+gd_main_icon_box_activate_cursor_child (GtkFlowBox *flow_box)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box);
+  GdMainIconBoxPrivate *priv;
+  GdkEvent *event = NULL;
+  gboolean initiating = FALSE;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  /* Use GtkFlowBox::activate-cursor-child instead of
+   * GtkWidget::key-press-event to catch key presses because it is
+   * easier to filter out non-activation keys.
+   */
+
+  event = gtk_get_current_event ();
+  if (event == NULL)
+    goto out;
+
+  if (event->type != GDK_KEY_PRESS)
+    goto out;
+
+  if (!priv->selection_mode && (event->key.state & GDK_CONTROL_MASK) != 0)
+    {
+      g_signal_emit_by_name (self, "selection-mode-request");
+      initiating = TRUE;
+    }
+
+  if (priv->selection_mode)
+    {
+      if (!initiating && (event->key.state & GDK_SHIFT_MASK) != 0)
+        priv->key_shift_pressed = TRUE;
+
+      priv->key_pressed = TRUE;
+    }
+
+ out:
+  GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->activate_cursor_child (flow_box);
+  g_clear_pointer (&event, (GDestroyNotify) gdk_event_free);
+}
+
+static gboolean
+gd_main_icon_box_button_press_event (GtkWidget *widget, GdkEventButton *event)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (widget);
+  GdMainIconBoxPrivate *priv;
+  GtkFlowBoxChild *child;
+  gboolean res;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (event->type != GDK_BUTTON_PRESS)
+    {
+      res = GDK_EVENT_STOP;
+      goto out;
+    }
+
+  if (event->button != GDK_BUTTON_PRIMARY)
+    goto default_behavior;
+
+  child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self), (gint) event->x, (gint) event->y);
+  if (child == NULL)
+    goto default_behavior;
+
+  if (priv->selection_mode && !gtk_flow_box_child_is_selected (child))
+    goto default_behavior;
+
+  priv->dnd_button = (gint) event->button;
+  priv->dnd_start_x = event->x;
+  priv->dnd_start_y = event->y;
+
+ default_behavior:
+  res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->button_press_event (widget, event);
+
+ out:
+  return res;
+}
+
+static gboolean
+gd_main_icon_box_button_release_event (GtkWidget *widget, GdkEventButton *event)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (widget);
+  GdMainIconBoxPrivate *priv;
+  GtkFlowBoxChild *child = NULL;
+  gboolean initiating = FALSE;
+  gboolean res;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  priv->dnd_button = -1;
+  priv->dnd_start_x = -1.0;
+  priv->dnd_start_y = -1.0;
+  priv->dnd_started = FALSE;
+
+  if (event->type != GDK_BUTTON_RELEASE)
+    {
+      res = GDK_EVENT_STOP;
+      goto out;
+    }
+
+  if (!priv->selection_mode &&
+      (event->button == GDK_BUTTON_PRIMARY && (event->state & GDK_CONTROL_MASK) != 0 ||
+       event->button == GDK_BUTTON_SECONDARY))
+    {
+      g_signal_emit_by_name (self, "selection-mode-request");
+      initiating = TRUE;
+    }
+
+  if (priv->selection_mode)
+    {
+      if (event->button == GDK_BUTTON_PRIMARY)
+        {
+          /* GtkFlowBox doesn't do range selection. It will simply
+           * select a single child for shift + left-click. We need to
+           * detect it so that we can handle it later.
+           *
+           * However, range selection is only possible if we were
+           * already in the selection mode. Therefore, skip it if we
+           * have just requested the selection mode.
+           */
+          if (!initiating && (event->state & GDK_SHIFT_MASK) != 0)
+            priv->left_button_shift_released = TRUE;
+
+          priv->left_button_released = TRUE;
+        }
+      else if (event->button == GDK_BUTTON_SECONDARY)
+        {
+          /* GtkFlowBox completely ignores the right mouse
+           * button.
+           */
+
+          child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self), (gint) event->x, (gint) event->y);
+          if (child != NULL)
+            {
+              gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self),
+                                                              GD_MAIN_BOX_CHILD (child),
+                                                              (!initiating &&
+                                                               (event->state & GDK_SHIFT_MASK) != 0));
+            }
+        }
+    }
+
+  /* This is for right-clicks and rubberband selection.
+   *
+   * Rubberband selection is unlike other modes of selection because
+   * GtkFlowBox::selected-children-changed is emitted before the mouse
+   * button is released.
+   */
+  if (priv->selection_changed)
+    {
+      g_signal_emit_by_name (self, "selection-changed");
+      gd_main_icon_box_update_last_selected_id (self, GD_MAIN_BOX_CHILD (child));
+      priv->selection_changed = FALSE;
+    }
+
+  res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->button_release_event (widget, event);
+
+ out:
+  return res;
+}
+
+static void
+gd_main_icon_box_child_activated (GtkFlowBox *flow_box, GtkFlowBoxChild *child)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box);
+  GdMainIconBoxPrivate *priv;
+  GdkEvent *event = NULL;
+
+  g_return_if_fail (GD_IS_MAIN_BOX_CHILD (child));
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  /* GtkFlowBox might emit child-activated in the middle of a
+   * DnD. See https://bugzilla.gnome.org/show_bug.cgi?id=776306
+   */
+  if (priv->dnd_started)
+    goto out;
+
+  if (!priv->selection_mode)
+    {
+      g_signal_emit_by_name (self, "item-activated", GD_MAIN_BOX_CHILD (child));
+      goto out;
+    }
+
+  event = gtk_get_current_event ();
+  if (event == NULL)
+    goto out;
+
+  if (priv->left_button_released && !priv->selection_changed)
+    {
+      /* If a selected child is left-clicked, GtkFlowBox will activate
+       * it without unselecting it.
+       */
+      gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self),
+                                                      GD_MAIN_BOX_CHILD (child),
+                                                      FALSE); /* One cannot unselect a range. */
+      priv->left_button_released = FALSE;
+      g_signal_emit_by_name (self, "selection-changed");
+    }
+  else if (priv->key_pressed && !priv->selection_changed)
+    {
+      /* If a selected child is activated by a keybinding, GtkFlowBox
+       * will not unselect it.
+       */
+      gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), GD_MAIN_BOX_CHILD (child), 
FALSE);
+      priv->key_pressed = FALSE;
+      g_signal_emit_by_name (self, "selection-changed");
+    }
+  else if (priv->left_button_shift_released || priv->key_shift_pressed)
+    {
+      /* GtkFlowBox doesn't do range selection and simply selects a
+       * single child. We handle it by unselecting the child and then
+       * selecting the range.
+       */
+      gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), GD_MAIN_BOX_CHILD (child), 
FALSE);
+      priv->left_button_shift_released = FALSE;
+      priv->key_shift_pressed = FALSE;
+      gd_main_box_generic_toggle_selection_for_child (GD_MAIN_BOX_GENERIC (self), GD_MAIN_BOX_CHILD (child), 
TRUE);
+      g_signal_emit_by_name (self, "selection-changed");
+    }
+  else if (priv->selection_changed)
+    {
+      /* This is for non-shift left-clicks and keyboard activation of
+       * unselected children.
+       */
+      g_signal_emit_by_name (self, "selection-changed");
+    }
+
+  g_signal_emit_by_name (self, "item-activated", GD_MAIN_BOX_CHILD (child));
+
+  if (priv->selection_changed)
+    {
+      gd_main_icon_box_update_last_selected_id (self, GD_MAIN_BOX_CHILD (child));
+      priv->selection_changed = FALSE;
+    }
+
+ out:
+  g_clear_pointer (&event, (GDestroyNotify) gdk_event_free);
+}
+
+static void
+gd_main_icon_box_drag_begin (GtkWidget *widget, GdkDragContext *context)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (widget);
+  GdMainIconBoxPrivate *priv;
+  GdMainBoxItem *item;
+  GtkFlowBoxChild *child;
+  cairo_surface_t *icon = NULL;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (priv->dnd_start_x < 0.0 || priv->dnd_start_y < 0.0)
+    goto out;
+
+  child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self),
+                                         (gint) priv->dnd_start_x,
+                                         (gint) priv->dnd_start_y);
+  if (child == NULL)
+    goto out;
+
+  item = gd_main_box_child_get_item (GD_MAIN_BOX_CHILD (child));
+  icon = copy_image_surface (gd_main_box_item_get_icon (item));
+  if (icon == NULL)
+    goto out;
+
+  if (priv->selection_mode)
+    {
+      GList *selected_children;
+      guint length;
+
+      selected_children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (self));
+      length = g_list_length (selected_children);
+      if (length > 1)
+        {
+          cairo_surface_t *icon_with_counter;
+
+          icon_with_counter = create_surface_with_counter (GTK_WIDGET (self), icon, length);
+          cairo_surface_destroy (icon);
+          icon = icon_with_counter;
+        }
+
+      g_list_free (selected_children);
+    }
+
+  cairo_surface_set_device_offset (icon, -MAIN_ICON_BOX_DND_ICON_OFFSET, -MAIN_ICON_BOX_DND_ICON_OFFSET);
+  gtk_drag_set_icon_surface (context, icon);
+
+ out:
+  g_clear_pointer (&icon, (GDestroyNotify) cairo_surface_destroy);
+}
+
+static void
+gd_main_icon_box_add_child_uri_to_array (GdMainBoxChild *child, GPtrArray *uri_array)
+{
+  GdMainBoxItem *item;
+  const gchar *uri;
+
+  item = gd_main_box_child_get_item (child);
+  uri = gd_main_box_item_get_uri (item);
+  g_ptr_array_add (uri_array, g_strdup (uri));
+}
+
+static void
+gd_main_icon_box_drag_data_get (GtkWidget *widget,
+                                GdkDragContext *context,
+                                GtkSelectionData *data,
+                                guint info,
+                                guint time)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (widget);
+  GdMainIconBoxPrivate *priv;
+  GPtrArray *uri_array = NULL;
+  gchar **uris = NULL;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (info != 0)
+    goto out;
+
+  if (priv->dnd_start_x < 0.0 || priv->dnd_start_y < 0.0)
+    goto out;
+
+  uri_array = g_ptr_array_new_with_free_func (g_free);
+
+  if (priv->selection_mode)
+    {
+      GList *l;
+      GList *selected_children;
+
+      selected_children = gtk_flow_box_get_selected_children (GTK_FLOW_BOX (self));
+      for (l = selected_children; l != NULL; l = l->next)
+        {
+          GdMainBoxChild *child = GD_MAIN_BOX_CHILD (l->data);
+          gd_main_icon_box_add_child_uri_to_array (child, uri_array);
+        }
+
+      g_list_free (selected_children);
+    }
+  else
+    {
+      GtkFlowBoxChild *child;
+
+      child = gtk_flow_box_get_child_at_pos (GTK_FLOW_BOX (self),
+                                             (gint) priv->dnd_start_x,
+                                             (gint) priv->dnd_start_y);
+
+      if (child != NULL)
+        gd_main_icon_box_add_child_uri_to_array (GD_MAIN_BOX_CHILD (child), uri_array);
+    }
+
+  g_ptr_array_add (uri_array, NULL);
+  gtk_selection_data_set_uris (data, (gchar **) uri_array->pdata);
+
+ out:
+  g_clear_pointer (&uri_array, (GDestroyNotify) g_ptr_array_unref);
+}
+
+static gboolean
+gd_main_icon_box_focus (GtkWidget *widget, GtkDirectionType direction)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (widget);
+  GdMainIconBoxPrivate *priv;
+  GdkEvent *event = NULL;
+  GdkEvent *fake_event = NULL;
+  gboolean res;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (!priv->selection_mode)
+    {
+      res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->focus (widget, direction);
+      goto out;
+    }
+
+  event = gtk_get_current_event ();
+  if (event->type != GDK_KEY_PRESS && event->type != GDK_KEY_RELEASE)
+    {
+      res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->focus (widget, direction);
+      goto out;
+    }
+
+  if ((event->key.state & GDK_CONTROL_MASK) != 0)
+    {
+      res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->focus (widget, direction);
+      goto out;
+    }
+
+  fake_event = gdk_event_copy (event);
+  fake_event->key.state |= GDK_CONTROL_MASK;
+
+  gtk_main_do_event (fake_event);
+  res = GDK_EVENT_STOP;
+
+ out:
+  g_clear_pointer (&fake_event, (GDestroyNotify) gdk_event_free);
+  g_clear_pointer (&event, (GDestroyNotify) gdk_event_free);
+  return res;
+}
+
+static gboolean
+gd_main_icon_box_motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (widget);
+  GdMainIconBoxPrivate *priv;
+  GtkTargetList *targets;
+  gboolean res;
+  gint button;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (priv->dnd_button < 0)
+    goto out;
+
+  if (!gtk_drag_check_threshold (GTK_WIDGET (self),
+                                 (gint) priv->dnd_start_x,
+                                 (gint) priv->dnd_start_y,
+                                 (gint) event->x,
+                                 (gint) event->y))
+      goto out;
+
+  button = priv->dnd_button;
+  priv->dnd_button = -1;
+  priv->dnd_started = TRUE;
+
+  targets = gtk_drag_source_get_target_list (GTK_WIDGET (self));
+
+  gtk_drag_begin_with_coordinates (GTK_WIDGET (self),
+                                   targets,
+                                   GDK_ACTION_COPY,
+                                   button,
+                                   (GdkEvent *) event,
+                                   (gint) priv->dnd_start_x,
+                                   (gint) priv->dnd_start_y);
+
+ out:
+  res = GTK_WIDGET_CLASS (gd_main_icon_box_parent_class)->motion_notify_event (widget, event);
+  return res;
+}
+
+static gboolean
+gd_main_icon_box_move_cursor (GtkFlowBox *flow_box, GtkMovementStep step, gint count)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box);
+  GdMainIconBoxPrivate *priv;
+  GdkEvent *event = NULL;
+  GdkEvent *fake_event = NULL;
+  gboolean res;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  if (!priv->selection_mode)
+    {
+      res = GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->move_cursor (flow_box, step, count);
+      goto out;
+    }
+
+  event = gtk_get_current_event ();
+  if (event->type != GDK_KEY_PRESS && event->type != GDK_KEY_RELEASE)
+    {
+      res = GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->move_cursor (flow_box, step, count);
+      goto out;
+    }
+
+  if ((event->key.state & GDK_CONTROL_MASK) != 0 && (event->key.state & GDK_SHIFT_MASK) == 0)
+    {
+      res = GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->move_cursor (flow_box, step, count);
+      goto out;
+    }
+
+  fake_event = gdk_event_copy (event);
+  fake_event->key.state |= GDK_CONTROL_MASK;
+  fake_event->key.state &= ~GDK_SHIFT_MASK;
+
+  gtk_main_do_event (fake_event);
+  res = GDK_EVENT_STOP;
+
+ out:
+  g_clear_pointer (&fake_event, (GDestroyNotify) gdk_event_free);
+  g_clear_pointer (&event, (GDestroyNotify) gdk_event_free);
+  return res;
+}
+
+static void
+gd_main_icon_box_select_all_flow_box (GtkFlowBox *flow_box)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->select_all (flow_box);
+
+  if (priv->selection_changed)
+    {
+      g_signal_emit_by_name (self, "selection-changed");
+      priv->selection_changed = FALSE;
+    }
+}
+
+static void
+gd_main_icon_box_selected_children_changed (GtkFlowBox *flow_box)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box);
+  GdMainIconBoxPrivate *priv;
+  gint i;
+  gint n_items;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  /* GtkFlowBox triggers selected-children-changed during dispose if
+   * there was any selected child. This means that we have to
+   * explicitly disconnect the signal handler to prevent it from being
+   * called in an inconsistent state.
+   *
+   * See https://bugzilla.gnome.org/show_bug.cgi?id=776012
+   */
+  if (gtk_widget_in_destruction (GTK_WIDGET (self)))
+    return;
+
+  GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->selected_children_changed (flow_box);
+
+  priv->selection_changed = TRUE;
+
+  /* When a range selection is attempted, we override GtkFlowBox's
+   * default behaviour by changing the selection ourselves. Therefore,
+   * there is no need to update the check buttons until the final
+   * selection is available.
+   */
+  if (!priv->key_shift_pressed && !priv->left_button_shift_released)
+    {
+      /* Work around https://bugzilla.gnome.org/show_bug.cgi?id=775525. */
+      n_items = (gint) g_list_model_get_n_items (G_LIST_MODEL (priv->model));
+      for (i = 0; i < n_items; i++)
+        {
+          GtkFlowBoxChild *child;
+          gboolean selected;
+
+          /* Work around the fact that GtkFlowBoxChild:selected is not
+           * a property.
+           */
+          child = gtk_flow_box_get_child_at_index (GTK_FLOW_BOX (self), i);
+          selected = gtk_flow_box_child_is_selected (child);
+          gd_main_box_child_set_selected (GD_MAIN_BOX_CHILD (child), selected);
+        }
+    }
+}
+
+static void
+gd_main_icon_box_unselect_all_flow_box (GtkFlowBox *flow_box)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (flow_box);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  GTK_FLOW_BOX_CLASS (gd_main_icon_box_parent_class)->unselect_all (flow_box);
+
+  if (priv->selection_changed)
+    {
+      g_signal_emit_by_name (self, "selection-changed");
+      priv->selection_changed = FALSE;
+    }
+}
+
+static void
+gd_main_icon_box_dispose (GObject *obj)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (obj);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  g_clear_object (&priv->model);
+
+  G_OBJECT_CLASS (gd_main_icon_box_parent_class)->dispose (obj);
+}
+
+static void
+gd_main_icon_box_finalize (GObject *obj)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (obj);
+  GdMainIconBoxPrivate *priv;
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  g_free (priv->last_selected_id);
+
+  G_OBJECT_CLASS (gd_main_icon_box_parent_class)->finalize (obj);
+}
+
+static void
+gd_main_icon_box_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (object);
+
+  switch (property_id)
+    {
+    case PROP_LAST_SELECTED_ID:
+      g_value_set_string (value, gd_main_icon_box_get_last_selected_id (GD_MAIN_BOX_GENERIC (self)));
+      break;
+    case PROP_MODEL:
+      g_value_set_object (value, gd_main_icon_box_get_model (self));
+      break;
+    case PROP_SELECTION_MODE:
+      g_value_set_boolean (value, gd_main_icon_box_get_selection_mode (self));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gd_main_icon_box_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
+{
+  GdMainIconBox *self = GD_MAIN_ICON_BOX (object);
+
+  switch (property_id)
+    {
+    case PROP_MODEL:
+      gd_main_icon_box_set_model (self, g_value_get_object (value));
+      break;
+    case PROP_SELECTION_MODE:
+      gd_main_icon_box_set_selection_mode (self, g_value_get_boolean (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gd_main_icon_box_init (GdMainIconBox *self)
+{
+  GdMainIconBoxPrivate *priv;
+  const GtkTargetEntry targets[] = { { (gchar *) "text/uri-list", GTK_TARGET_OTHER_APP, 0 } };
+
+  priv = gd_main_icon_box_get_instance_private (self);
+
+  gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
+  gtk_flow_box_set_homogeneous (GTK_FLOW_BOX (self), TRUE);
+  gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (self), 3);
+  gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (self), GTK_SELECTION_NONE);
+
+  /* We need to ensure that rubberband selection and DnD don't step
+   * on each others toes. We set start_button_mask to 0 to retain
+   * control over when to begin a drag.
+   */
+  gtk_drag_source_set (GTK_WIDGET (self), 0, targets, G_N_ELEMENTS (targets), GDK_ACTION_COPY);
+
+  priv->dnd_button = -1;
+  priv->dnd_start_x = -1.0;
+  priv->dnd_start_y = -1.0;
+}
+
+static void
+gd_main_icon_box_class_init (GdMainIconBoxClass *klass)
+{
+  GObjectClass *oclass = G_OBJECT_CLASS (klass);
+  GtkFlowBoxClass *fbclass = GTK_FLOW_BOX_CLASS (klass);
+  GtkWidgetClass *wclass = GTK_WIDGET_CLASS (klass);
+  GtkBindingSet *binding_set;
+  GdkModifierType activate_modifiers[] = { 0, /* Otherwise it will go to GtkFlowBoxChild::activate. */
+                                           GDK_SHIFT_MASK,
+                                           GDK_CONTROL_MASK,
+                                           GDK_SHIFT_MASK | GDK_CONTROL_MASK };
+  guint i;
+
+  binding_set = gtk_binding_set_by_class (klass);
+
+  oclass->dispose = gd_main_icon_box_dispose;
+  oclass->finalize = gd_main_icon_box_finalize;
+  oclass->get_property = gd_main_icon_box_get_property;
+  oclass->set_property = gd_main_icon_box_set_property;
+  wclass->button_press_event = gd_main_icon_box_button_press_event;
+  wclass->button_release_event = gd_main_icon_box_button_release_event;
+  wclass->drag_begin = gd_main_icon_box_drag_begin;
+  wclass->drag_data_get = gd_main_icon_box_drag_data_get;
+  wclass->focus = gd_main_icon_box_focus;
+  wclass->motion_notify_event = gd_main_icon_box_motion_notify_event;
+  fbclass->activate_cursor_child = gd_main_icon_box_activate_cursor_child;
+  fbclass->child_activated = gd_main_icon_box_child_activated;
+  fbclass->move_cursor = gd_main_icon_box_move_cursor;
+  fbclass->select_all = gd_main_icon_box_select_all_flow_box;
+  fbclass->selected_children_changed = gd_main_icon_box_selected_children_changed;
+  fbclass->unselect_all = gd_main_icon_box_unselect_all_flow_box;
+
+  g_object_class_override_property (oclass, PROP_LAST_SELECTED_ID, "last-selected-id");
+  g_object_class_override_property (oclass, PROP_MODEL, "model");
+  g_object_class_override_property (oclass, PROP_SELECTION_MODE, "gd-selection-mode");
+
+  for (i = 0; i < G_N_ELEMENTS (activate_modifiers); i++)
+    {
+      gtk_binding_entry_add_signal (binding_set,
+                                    GDK_KEY_space, activate_modifiers[i],
+                                    "activate-cursor-child",
+                                    0);
+      gtk_binding_entry_add_signal (binding_set,
+                                    GDK_KEY_KP_Space, activate_modifiers[i],
+                                    "activate-cursor-child",
+                                    0);
+      gtk_binding_entry_add_signal (binding_set,
+                                    GDK_KEY_Return, activate_modifiers[i],
+                                    "activate-cursor-child",
+                                    0);
+      gtk_binding_entry_add_signal (binding_set,
+                                    GDK_KEY_ISO_Enter, activate_modifiers[i],
+                                    "activate-cursor-child",
+                                    0);
+      gtk_binding_entry_add_signal (binding_set,
+                                    GDK_KEY_KP_Enter, activate_modifiers[i],
+                                    "activate-cursor-child",
+                                    0);
+    }
+}
+
+static void
+gd_main_box_generic_interface_init (GdMainBoxGenericInterface *iface)
+{
+  iface->get_child_at_index = gd_main_icon_box_get_child_at_index;
+  iface->get_last_selected_id = gd_main_icon_box_get_last_selected_id;
+  iface->get_selected_children = gd_main_icon_box_get_selected_children;
+  iface->select_all = gd_main_icon_box_select_all_generic;
+  iface->select_child = gd_main_icon_box_select_child;
+  iface->unselect_all = gd_main_icon_box_unselect_all_generic;
+  iface->unselect_child = gd_main_icon_box_unselect_child;
+}
+
+GtkWidget *
+gd_main_icon_box_new (void)
+{
+  return g_object_new (GD_TYPE_MAIN_ICON_BOX, NULL);
+}
diff --git a/libgd/gd-main-icon-box.h b/libgd/gd-main-icon-box.h
new file mode 100644
index 0000000..5dc60fe
--- /dev/null
+++ b/libgd/gd-main-icon-box.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2016 Red Hat, Inc.
+ *
+ * This program 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 program 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 program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Author: Debarshi Ray <debarshir gnome org>
+ *
+ */
+
+#ifndef __GD_MAIN_ICON_BOX_H__
+#define __GD_MAIN_ICON_BOX_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GD_TYPE_MAIN_ICON_BOX gd_main_icon_box_get_type()
+G_DECLARE_DERIVABLE_TYPE (GdMainIconBox, gd_main_icon_box, GD, MAIN_ICON_BOX, GtkFlowBox)
+
+struct _GdMainIconBoxClass
+{
+  GtkFlowBoxClass parent_class;
+
+  /* signals */
+  gboolean  (* move_cursor)            (GdMainIconBox *self, GtkMovementStep step, gint count);
+};
+
+GtkWidget * gd_main_icon_box_new (void);
+
+G_END_DECLS
+
+#endif /* __GD_MAIN_ICON_BOX_H__ */