/*
 * nbtk-scroll-view.h: Container with scroll-bars
 *
 * Copyright 2008 OpenedHand
 * Copyright 2009 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU Lesser General Public License,
 * version 2.1, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.
 *
 * Written by: Chris Lord <chris@openedhand.com>
 * Port to Nbtk by: Robert Staudinger <robsta@openedhand.com>
 *
 */

#include "nbtk-scroll-view.h"
#include "nbtk-marshal.h"
#include "nbtk-scroll-bar.h"
#include "nbtk-scrollable.h"
#include "nbtk-stylable.h"
#include <clutter/clutter.h>

static void clutter_container_iface_init (ClutterContainerIface *iface);
static void nbtk_stylable_iface_init (NbtkStylableIface *iface);

static ClutterContainerIface *nbtk_scroll_view_parent_iface = NULL;

G_DEFINE_TYPE_WITH_CODE (NbtkScrollView, nbtk_scroll_view, NBTK_TYPE_BIN,
                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
                                                clutter_container_iface_init)
                         G_IMPLEMENT_INTERFACE (NBTK_TYPE_STYLABLE,
                                                nbtk_stylable_iface_init))

#define SCROLL_VIEW_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
                                NBTK_TYPE_SCROLL_VIEW, \
                                NbtkScrollViewPrivate))

struct _NbtkScrollViewPrivate
{
  /* a pointer to the child; this is actually stored
   * inside NbtkBin:child, but we keep it to avoid
   * calling nbtk_bin_get_child() every time we need it
   */
  ClutterActor   *child;

  ClutterActor   *hscroll;
  ClutterActor   *vscroll;

  gfloat          row_size;
  gfloat          column_size;

  gboolean        row_size_set : 1;
  gboolean        column_size_set : 1;
  guint           mouse_scroll : 1;
};

enum {
  PROP_0,

  PROP_HSCROLL,
  PROP_VSCROLL,
  PROP_MOUSE_SCROLL
};

static void
nbtk_scroll_view_get_property (GObject *object, guint property_id,
                                 GValue *value, GParamSpec *pspec)
{
  NbtkScrollViewPrivate *priv = ((NbtkScrollView *)object)->priv;

  switch (property_id)
    {
    case PROP_HSCROLL :
      g_value_set_object (value, priv->hscroll);
      break;
    case PROP_VSCROLL :
      g_value_set_object (value, priv->vscroll);
      break;
    case PROP_MOUSE_SCROLL:
      g_value_set_boolean (value, priv->mouse_scroll);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
nbtk_scroll_view_set_property (GObject *object, guint property_id,
                                 const GValue *value, GParamSpec *pspec)
{
  switch (property_id)
    {
    case PROP_MOUSE_SCROLL:
      nbtk_scroll_view_set_mouse_scrolling ((NbtkScrollView *) object,
                                         g_value_get_boolean (value));
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    }
}

static void
nbtk_scroll_view_dispose (GObject *object)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (object)->priv;

  priv->child = NULL;

  if (priv->vscroll)
    {
      clutter_actor_unparent (priv->vscroll);
      priv->vscroll = NULL;
    }

  if (priv->hscroll)
    {
      clutter_actor_unparent (priv->hscroll);
      priv->hscroll = NULL;
    }

  G_OBJECT_CLASS (nbtk_scroll_view_parent_class)->dispose (object);
}

static void
nbtk_scroll_view_finalize (GObject *object)
{
  G_OBJECT_CLASS (nbtk_scroll_view_parent_class)->finalize (object);
}

static void
nbtk_scroll_view_paint (ClutterActor *actor)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (actor)->priv;

  /* NbtkBin will paint the child */
  CLUTTER_ACTOR_CLASS (nbtk_scroll_view_parent_class)->paint (actor);

  /* paint our custom children */
  if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
    clutter_actor_paint (priv->hscroll);
  if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
    clutter_actor_paint (priv->vscroll);
}

static void
nbtk_scroll_view_pick (ClutterActor *actor, const ClutterColor *color)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (actor)->priv;

  /* Chain up so we get a bounding box pained (if we are reactive) */
  CLUTTER_ACTOR_CLASS (nbtk_scroll_view_parent_class)->pick (actor, color);

  /* paint our custom children */
  if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
    clutter_actor_paint (priv->hscroll);
  if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
    clutter_actor_paint (priv->vscroll);
}

static void
nbtk_scroll_view_get_preferred_width (ClutterActor *actor,
                                      gfloat        for_height,
                                      gfloat       *min_width_p,
                                      gfloat       *natural_width_p)
{
  NbtkPadding padding;
  guint xthickness;

  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (actor)->priv;

  if (!priv->child)
    return;

  nbtk_widget_get_padding (NBTK_WIDGET (actor), &padding);
  nbtk_stylable_get (NBTK_STYLABLE (actor),
                     "scrollbar-width", &xthickness,
                     NULL);

  /* Our natural width is the natural width of the child */
  clutter_actor_get_preferred_width (priv->child,
                                     for_height,
                                     NULL,
                                     natural_width_p);

  /* Add space for the scroll-bar if we can determine it will be necessary */
  if ((for_height >= 0) && natural_width_p)
    {
      gfloat natural_height;

      clutter_actor_get_preferred_height (priv->child, -1.0,
                                          NULL,
                                          &natural_height);
      if (for_height < natural_height)
        *natural_width_p += xthickness;
    }

  /* Add space for padding */
  if (min_width_p)
    *min_width_p = padding.left + padding.right;

  if (natural_width_p)
    *natural_width_p += padding.left + padding.right;
}

static void
nbtk_scroll_view_get_preferred_height (ClutterActor *actor,
                                       gfloat        for_width,
                                       gfloat       *min_height_p,
                                       gfloat       *natural_height_p)
{
  NbtkPadding padding;
  guint ythickness;

  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (actor)->priv;

  if (!priv->child)
    return;

  nbtk_widget_get_padding (NBTK_WIDGET (actor), &padding);
  nbtk_stylable_get (NBTK_STYLABLE (actor),
                     "scrollbar-height", &ythickness,
                     NULL);

  /* Our natural height is the natural height of the child */
  clutter_actor_get_preferred_height (priv->child,
                                      for_width,
                                      NULL,
                                      natural_height_p);

  /* Add space for the scroll-bar if we can determine it will be necessary */
  if ((for_width >= 0) && natural_height_p)
    {
      gfloat natural_width;

      clutter_actor_get_preferred_width (priv->child, -1.0,
                                         NULL,
                                         &natural_width);
      if (for_width < natural_width)
        *natural_height_p += ythickness;
    }

  /* Add space for padding */
  if (min_height_p)
    *min_height_p = padding.top + padding.bottom;

  if (natural_height_p)
    *natural_height_p += padding.top + padding.bottom;
}

static void
nbtk_scroll_view_allocate (ClutterActor          *actor,
                           const ClutterActorBox *box,
                           ClutterAllocationFlags flags)
{
  NbtkPadding padding;
  ClutterActorBox child_box;
  ClutterActorClass *parent_parent_class;
  gfloat avail_width, avail_height, sb_width, sb_height;

  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (actor)->priv;

  /* Chain up to the parent's parent class
   *
   * We do this because we do not want NbtkBin to allocate the child, as we
   * give it a different allocation later, depending on whether the scrollbars
   * are visible
   */
  parent_parent_class
    = g_type_class_peek_parent (nbtk_scroll_view_parent_class);

  CLUTTER_ACTOR_CLASS (parent_parent_class)->
    allocate (actor, box, flags);


  nbtk_widget_get_padding (NBTK_WIDGET (actor), &padding);

  avail_width = (box->x2 - box->x1) - padding.left - padding.right;
  avail_height = (box->y2 - box->y1) - padding.top - padding.bottom;

  nbtk_stylable_get (NBTK_STYLABLE (actor),
                     "scrollbar-width", &sb_width,
                     "scrollbar-height", &sb_height,
                     NULL);

  if (!CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
    sb_width = 0;

  if (!CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
    sb_height = 0;

  /* Vertical scrollbar */
  if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
    {
      child_box.x1 = avail_width - sb_width;
      child_box.y1 = padding.top;
      child_box.x2 = avail_width;
      child_box.y2 = child_box.y1 + avail_height - sb_height;

      clutter_actor_allocate (priv->vscroll, &child_box, flags);
    }

  /* Horizontal scrollbar */
  if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
    {
      child_box.x1 = padding.left;
      child_box.x2 = child_box.x1 + avail_width - sb_width;
      child_box.y1 = avail_height - sb_height;
      child_box.y2 = avail_height;

      clutter_actor_allocate (priv->hscroll, &child_box, flags);
    }


  /* Child */
  child_box.x1 = padding.left;
  child_box.x2 = avail_width - sb_width;
  child_box.y1 = padding.top;
  child_box.y2 = avail_height - sb_height;

  if (priv->child)
      clutter_actor_allocate (priv->child, &child_box, flags);
}

static void
nbtk_scroll_view_style_changed (NbtkWidget *widget)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (widget)->priv;

  nbtk_stylable_changed ((NbtkStylable *) priv->hscroll);
  nbtk_stylable_changed ((NbtkStylable *) priv->vscroll);
}

static gboolean
nbtk_scroll_view_scroll_event (ClutterActor        *self,
                               ClutterScrollEvent  *event)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (self)->priv;
  gdouble lower, value, upper, step;
  NbtkAdjustment *vadjustment, *hadjustment;

  /* don't handle scroll events if requested not to */
  if (!priv->mouse_scroll)
    return FALSE;

  hadjustment = nbtk_scroll_bar_get_adjustment (NBTK_SCROLL_BAR(priv->hscroll));
  vadjustment = nbtk_scroll_bar_get_adjustment (NBTK_SCROLL_BAR(priv->vscroll));

  switch (event->direction)
    {
      case CLUTTER_SCROLL_UP:
      case CLUTTER_SCROLL_DOWN:
        if (vadjustment)
          g_object_get (vadjustment,
                        "lower", &lower,
                        "step-increment", &step,
                        "value", &value,
                        "upper", &upper,
                        NULL);
        else
          return FALSE;
        break;
      case CLUTTER_SCROLL_LEFT:
      case CLUTTER_SCROLL_RIGHT:
        if (vadjustment)
          g_object_get (hadjustment,
                        "lower", &lower,
                        "step-increment", &step,
                        "value", &value,
                        "upper", &upper,
                        NULL);
          else
            return FALSE;
        break;
    }

  switch (event->direction)
    {
      case CLUTTER_SCROLL_UP:
        if (value == lower)
          return FALSE;
        else
          nbtk_adjustment_set_value (vadjustment, value - step);
        break;
      case CLUTTER_SCROLL_DOWN:
        if (value == upper)
          return FALSE;
        else
          nbtk_adjustment_set_value (vadjustment, value + step);
        break;
      case CLUTTER_SCROLL_LEFT:
        if (value == lower)
          return FALSE;
        else
          nbtk_adjustment_set_value (hadjustment, value - step);
        break;
      case CLUTTER_SCROLL_RIGHT:
        if (value == upper)
          return FALSE;
        else
          nbtk_adjustment_set_value (hadjustment, value + step);
        break;
    }

  return TRUE;
}

static void
nbtk_scroll_view_class_init (NbtkScrollViewClass *klass)
{
  GParamSpec *pspec;
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);

  g_type_class_add_private (klass, sizeof (NbtkScrollViewPrivate));

  object_class->get_property = nbtk_scroll_view_get_property;
  object_class->set_property = nbtk_scroll_view_set_property;
  object_class->dispose= nbtk_scroll_view_dispose;
  object_class->finalize = nbtk_scroll_view_finalize;

  actor_class->paint = nbtk_scroll_view_paint;
  actor_class->pick = nbtk_scroll_view_pick;
  actor_class->get_preferred_width = nbtk_scroll_view_get_preferred_width;
  actor_class->get_preferred_height = nbtk_scroll_view_get_preferred_height;
  actor_class->allocate = nbtk_scroll_view_allocate;
  actor_class->scroll_event = nbtk_scroll_view_scroll_event;

  g_object_class_install_property (object_class,
                                   PROP_HSCROLL,
                                   g_param_spec_object ("hscroll",
                                                        "NbtkScrollBar",
                                                        "Horizontal scroll indicator",
                                                        NBTK_TYPE_SCROLL_BAR,
                                                        G_PARAM_READABLE));

  g_object_class_install_property (object_class,
                                   PROP_VSCROLL,
                                   g_param_spec_object ("vscroll",
                                                       "NbtkScrollBar",
                                                       "Vertical scroll indicator",
                                                       NBTK_TYPE_SCROLL_BAR,
                                                       G_PARAM_READABLE));

  pspec = g_param_spec_boolean ("enable-mouse-scrolling",
                                "Enable Mouse Scrolling",
                                "Enable automatic mouse wheel scrolling",
                                TRUE,
                                G_PARAM_READWRITE);
  g_object_class_install_property (object_class,
                                   PROP_MOUSE_SCROLL,
                                   pspec);

}

static void
nbtk_stylable_iface_init (NbtkStylableIface *iface)
{
  static gboolean is_initialized = FALSE;

  if (!is_initialized)
    {
      GParamSpec *pspec;

      is_initialized = TRUE;

      pspec = g_param_spec_uint ("scrollbar-width",
                                  "Vertical scroll-bar thickness",
                                  "Thickness of vertical scrollbar, in px",
                                  0, G_MAXUINT, 24,
                                  G_PARAM_READWRITE);
      nbtk_stylable_iface_install_property (iface, NBTK_TYPE_SCROLL_VIEW, pspec);

      pspec = g_param_spec_uint ("scrollbar-height",
                                  "Horizontal scroll-bar thickness",
                                  "Thickness of horizontal scrollbar, in px",
                                  0, G_MAXUINT, 24,
                                  G_PARAM_READWRITE);
      nbtk_stylable_iface_install_property (iface, NBTK_TYPE_SCROLL_VIEW, pspec);
    }
}

static void
child_adjustment_changed_cb (NbtkAdjustment *adjustment,
                             ClutterActor   *bar)
{
  NbtkScrollView *scroll;
  gdouble lower, upper, page_size;

  scroll = NBTK_SCROLL_VIEW (clutter_actor_get_parent (bar));

  /* Determine if this scroll-bar should be visible */
  nbtk_adjustment_get_values (adjustment, NULL,
                              &lower, &upper,
                              NULL, NULL,
                              &page_size);

  if ((upper - lower) > page_size)
    clutter_actor_show (bar);
  else
    clutter_actor_hide (bar);

  /* Request a resize */
  clutter_actor_queue_relayout (CLUTTER_ACTOR (scroll));
}

static void
child_hadjustment_notify_cb (GObject *gobject,
                             GParamSpec *arg1,
                             gpointer user_data)
{
  NbtkAdjustment *hadjust;

  ClutterActor *actor = CLUTTER_ACTOR (gobject);
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (user_data)->priv;

  hadjust = nbtk_scroll_bar_get_adjustment (NBTK_SCROLL_BAR(priv->hscroll));
  if (hadjust)
    g_signal_handlers_disconnect_by_func (hadjust,
                                          child_adjustment_changed_cb,
                                          priv->hscroll);

  nbtk_scrollable_get_adjustments (NBTK_SCROLLABLE (actor), &hadjust, NULL);
  if (hadjust)
    {
      /* Force scroll step if neede. */
      if (priv->column_size_set)
        {
          g_object_set (hadjust,
                        "step-increment", priv->column_size,
                        NULL);
        }

      nbtk_scroll_bar_set_adjustment (NBTK_SCROLL_BAR(priv->hscroll), hadjust);
      g_signal_connect (hadjust, "changed", G_CALLBACK (
                        child_adjustment_changed_cb), priv->hscroll);
      child_adjustment_changed_cb (hadjust, priv->hscroll);
    }
}

static void
child_vadjustment_notify_cb (GObject *gobject,
                             GParamSpec *arg1,
                             gpointer user_data)
{
  NbtkAdjustment *vadjust;

  ClutterActor *actor = CLUTTER_ACTOR (gobject);
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (user_data)->priv;

  vadjust = nbtk_scroll_bar_get_adjustment (NBTK_SCROLL_BAR(priv->vscroll));
  if (vadjust)
    g_signal_handlers_disconnect_by_func (vadjust,
                                          child_adjustment_changed_cb,
                                          priv->vscroll);

  nbtk_scrollable_get_adjustments (NBTK_SCROLLABLE(actor), NULL, &vadjust);
  if (vadjust)
    {
      /* Force scroll step if neede. */
      if (priv->row_size_set)
        {
          g_object_set (vadjust,
                        "step-increment", priv->row_size,
                        NULL);
        }

      nbtk_scroll_bar_set_adjustment (NBTK_SCROLL_BAR(priv->vscroll), vadjust);
      g_signal_connect (vadjust, "changed", G_CALLBACK (
                        child_adjustment_changed_cb), priv->vscroll);
      child_adjustment_changed_cb (vadjust, priv->vscroll);
    }
}

static void
nbtk_scroll_view_init (NbtkScrollView *self)
{
  NbtkScrollViewPrivate *priv = self->priv = SCROLL_VIEW_PRIVATE (self);

  priv->hscroll = CLUTTER_ACTOR (nbtk_scroll_bar_new (NULL));
  priv->vscroll = g_object_new (NBTK_TYPE_SCROLL_BAR, "vertical", TRUE, NULL);

  clutter_actor_set_parent (priv->hscroll, CLUTTER_ACTOR (self));
  clutter_actor_set_parent (priv->vscroll, CLUTTER_ACTOR (self));

  /* mouse scroll is enabled by default, so we also need to be reactive */
  priv->mouse_scroll = TRUE;
  g_object_set (G_OBJECT (self), "reactive", TRUE, "clip-to-allocation", TRUE,
                NULL);

  g_signal_connect (self, "style-changed",
                    G_CALLBACK (nbtk_scroll_view_style_changed), NULL);
}

static void
nbtk_scroll_view_add (ClutterContainer *container,
                      ClutterActor     *actor)
{
  NbtkScrollView *self = NBTK_SCROLL_VIEW (container);
  NbtkScrollViewPrivate *priv = self->priv;

  if (NBTK_IS_SCROLLABLE (actor))
    {
      priv->child = actor;

      /* chain up to NbtkBin::add() */
      nbtk_scroll_view_parent_iface->add (container, actor);

      /* Get adjustments for scroll-bars */
      g_signal_connect (actor, "notify::hadjustment",
                        G_CALLBACK (child_hadjustment_notify_cb),
                        container);
      g_signal_connect (actor, "notify::vadjustment",
                        G_CALLBACK (child_vadjustment_notify_cb),
                        container);
      child_hadjustment_notify_cb (G_OBJECT (actor), NULL, container);
      child_vadjustment_notify_cb (G_OBJECT (actor), NULL, container);
    }
  else
    {
      g_warning ("Attempting to add an actor of type %s to "
                 "a NbtkScrollView, but the actor does "
                 "not implement NbtkScrollable.",
                 g_type_name (G_OBJECT_TYPE (actor)));
    }
}

static void
nbtk_scroll_view_remove (ClutterContainer *container,
                         ClutterActor     *actor)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (container)->priv;

  if (actor == priv->child)
    {
      g_object_ref (priv->child);

      /* chain up to NbtkBin::remove() */
      nbtk_scroll_view_parent_iface->remove (container, actor);

      g_signal_handlers_disconnect_by_func (priv->child,
                                            child_hadjustment_notify_cb,
                                            container);
      g_signal_handlers_disconnect_by_func (priv->child,
                                            child_vadjustment_notify_cb,
                                            container);
      nbtk_scrollable_set_adjustments ((NbtkScrollable*) priv->child, NULL, NULL);

      g_object_unref (priv->child);
      priv->child = NULL;
    }
}

static void
nbtk_scroll_view_foreach_with_internals (ClutterContainer *container,
                                         ClutterCallback   callback,
                                         gpointer          user_data)
{
  NbtkScrollViewPrivate *priv = NBTK_SCROLL_VIEW (container)->priv;

  if (priv->child != NULL)
    callback (priv->child, user_data);

  if (priv->hscroll != NULL)
    callback (priv->hscroll, user_data);

  if (priv->vscroll != NULL)
    callback (priv->vscroll, user_data);
}

static void
clutter_container_iface_init (ClutterContainerIface *iface)
{
  /* store a pointer to the NbtkBin implementation of
   * ClutterContainer so that we can chain up when
   * overriding the methods
   */
  nbtk_scroll_view_parent_iface = g_type_interface_peek_parent (iface);

  iface->add = nbtk_scroll_view_add;
  iface->remove = nbtk_scroll_view_remove;
  iface->foreach_with_internals = nbtk_scroll_view_foreach_with_internals;
}

NbtkWidget *
nbtk_scroll_view_new (void)
{
  return g_object_new (NBTK_TYPE_SCROLL_VIEW, NULL);
}

ClutterActor *
nbtk_scroll_view_get_hscroll_bar (NbtkScrollView *scroll)
{
  g_return_val_if_fail (NBTK_IS_SCROLL_VIEW (scroll), NULL);

  return scroll->priv->hscroll;
}

ClutterActor *
nbtk_scroll_view_get_vscroll_bar (NbtkScrollView *scroll)
{
  g_return_val_if_fail (NBTK_IS_SCROLL_VIEW (scroll), NULL);

  return scroll->priv->vscroll;
}

gfloat
nbtk_scroll_view_get_column_size (NbtkScrollView *scroll)
{
  NbtkAdjustment  *adjustment;
  gdouble          column_size;

  g_return_val_if_fail (scroll, 0);

  adjustment = nbtk_scroll_bar_get_adjustment (
                NBTK_SCROLL_BAR (scroll->priv->hscroll));
  g_object_get (adjustment,
                "step-increment", &column_size,
                NULL);

  return column_size;
}

void
nbtk_scroll_view_set_column_size (NbtkScrollView *scroll,
                                  gfloat          column_size)
{
  NbtkAdjustment  *adjustment;

  g_return_if_fail (scroll);

  if (column_size < 0)
    {
      scroll->priv->column_size_set = FALSE;
      scroll->priv->column_size = -1;
    }
  else
    {
      scroll->priv->column_size_set = TRUE;
      scroll->priv->column_size = column_size;

      adjustment = nbtk_scroll_bar_get_adjustment (
                    NBTK_SCROLL_BAR (scroll->priv->hscroll));

      if (adjustment)
        g_object_set (adjustment,
                      "step-increment", (gdouble) scroll->priv->column_size,
                      NULL);
     }
}

gfloat
nbtk_scroll_view_get_row_size (NbtkScrollView *scroll)
{
  NbtkAdjustment  *adjustment;
  gdouble row_size;

  g_return_val_if_fail (scroll, 0);

  adjustment = nbtk_scroll_bar_get_adjustment (
                NBTK_SCROLL_BAR (scroll->priv->vscroll));
  g_object_get (adjustment,
                "step-increment", &row_size,
                NULL);

  return row_size;
}

void
nbtk_scroll_view_set_row_size (NbtkScrollView *scroll,
                               gfloat          row_size)
{
  NbtkAdjustment  *adjustment;

  g_return_if_fail (scroll);

  if (row_size < 0)
    {
      scroll->priv->row_size_set = FALSE;
      scroll->priv->row_size = -1;
    }
  else
    {
      scroll->priv->row_size_set = TRUE;
      scroll->priv->row_size = row_size;

      adjustment = nbtk_scroll_bar_get_adjustment (
                    NBTK_SCROLL_BAR (scroll->priv->vscroll));

      if (adjustment)
        g_object_set (adjustment,
                      "step-increment", (gdouble) scroll->priv->row_size,
                      NULL);
    }
}

void
nbtk_scroll_view_set_mouse_scrolling (NbtkScrollView *scroll,
                                      gboolean        enabled)
{
  NbtkScrollViewPrivate *priv;

  g_return_if_fail (NBTK_IS_SCROLL_VIEW (scroll));

  priv = NBTK_SCROLL_VIEW (scroll)->priv;

  if (priv->mouse_scroll != enabled)
    {
      priv->mouse_scroll = enabled;

      /* make sure we can receive mouse wheel events */
      if (enabled)
        clutter_actor_set_reactive ((ClutterActor *) scroll, TRUE);
    }
}

gboolean
nbtk_scroll_view_get_mouse_scrolling (NbtkScrollView *scroll)
{
  NbtkScrollViewPrivate *priv;

  g_return_val_if_fail (NBTK_IS_SCROLL_VIEW (scroll), FALSE);

  priv = NBTK_SCROLL_VIEW (scroll)->priv;

  return priv->mouse_scroll;
}