path: root/gtk/gtkgesturepan.c

/* GTK - The GIMP Toolkit
 * Copyright (C) 2014, 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/>.
 *
 * Author(s): Carlos Garnacho <carlosg@gnome.org>
 */

/**
 * SECTION:gtkgesturepan
 * @Short_description: Pan gesture
 * @Title: GtkGesturePan
 *
 * #GtkGesturePan is a #GtkGesture implementation able to recognize
 * pan gestures, those are drags that are locked to happen along one
 * axis. The axis that a #GtkGesturePan handles is defined at
 * construct time, and can be changed through
 * gtk_gesture_pan_set_orientation().
 *
 * When the gesture starts to be recognized, #GtkGesturePan will
 * attempt to determine as early as possible whether the sequence
 * is moving in the expected direction, and denying the sequence if
 * this does not happen.
 *
 * Once a panning gesture along the expected axis is recognized,
 * the #GtkGesturePan::pan signal will be emitted as input events
 * are received, containing the offset in the given axis.
 */

#include "config.h"
#include "gtkgesturepan.h"
#include "gtkgesturepanprivate.h"
#include "gtktypebuiltins.h"
#include "gtkprivate.h"
#include "gtkintl.h"

typedef struct _GtkGesturePanPrivate GtkGesturePanPrivate;

struct _GtkGesturePanPrivate
{
  guint orientation : 2;
  guint panning     : 1;
};

enum {
  PROP_ORIENTATION = 1
};

enum {
  PAN,
  N_SIGNALS
};

static guint signals[N_SIGNALS] = { 0 };

G_DEFINE_TYPE_WITH_PRIVATE (GtkGesturePan, gtk_gesture_pan, GTK_TYPE_GESTURE_DRAG)

static void
gtk_gesture_pan_get_property (GObject    *object,
                              guint       prop_id,
                              GValue     *value,
                              GParamSpec *pspec)
{
  GtkGesturePanPrivate *priv;

  priv = gtk_gesture_pan_get_instance_private (GTK_GESTURE_PAN (object));

  switch (prop_id)
    {
    case PROP_ORIENTATION:
      g_value_set_enum (value, priv->orientation);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
gtk_gesture_pan_set_property (GObject      *object,
                              guint         prop_id,
                              const GValue *value,
                              GParamSpec   *pspec)
{
  switch (prop_id)
    {
    case PROP_ORIENTATION:
      gtk_gesture_pan_set_orientation (GTK_GESTURE_PAN (object),
                                       g_value_get_enum (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
direction_from_offset (gdouble          offset_x,
                       gdouble          offset_y,
                       GtkOrientation   orientation,
                       GtkPanDirection *direction)
{
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      if (offset_x > 0)
        *direction = GTK_PAN_DIRECTION_RIGHT;
      else
        *direction = GTK_PAN_DIRECTION_LEFT;
    }
  else if (orientation == GTK_ORIENTATION_VERTICAL)
    {
      if (offset_y > 0)
        *direction = GTK_PAN_DIRECTION_DOWN;
      else
        *direction = GTK_PAN_DIRECTION_UP;
    }
  else
    g_assert_not_reached ();
}

static gboolean
guess_direction (GtkGesturePan   *gesture,
                 gdouble          offset_x,
                 gdouble          offset_y,
                 GtkPanDirection *direction)
{
  gdouble abs_x, abs_y;

  abs_x = ABS (offset_x);
  abs_y = ABS (offset_y);

#define FACTOR 2
  if (abs_x > abs_y * FACTOR)
    direction_from_offset (offset_x, offset_y,
                           GTK_ORIENTATION_HORIZONTAL, direction);
  else if (abs_y > abs_x * FACTOR)
    direction_from_offset (offset_x, offset_y,
                           GTK_ORIENTATION_VERTICAL, direction);
  else
    return FALSE;

  return TRUE;
#undef FACTOR
}

static gboolean
check_orientation_matches (GtkGesturePan   *gesture,
                           GtkPanDirection  direction)
{
  GtkGesturePanPrivate *priv = gtk_gesture_pan_get_instance_private (gesture);

  return (((direction == GTK_PAN_DIRECTION_LEFT ||
            direction == GTK_PAN_DIRECTION_RIGHT) &&
           priv->orientation == GTK_ORIENTATION_HORIZONTAL) ||
          ((direction == GTK_PAN_DIRECTION_UP ||
            direction == GTK_PAN_DIRECTION_DOWN) &&
           priv->orientation == GTK_ORIENTATION_VERTICAL));
}

static void
gtk_gesture_pan_drag_update (GtkGestureDrag *gesture,
                             gdouble         offset_x,
                             gdouble         offset_y)
{
  GtkGesturePanPrivate *priv;
  GtkPanDirection direction;
  GtkGesturePan *pan;
  gdouble offset;

  pan = GTK_GESTURE_PAN (gesture);
  priv = gtk_gesture_pan_get_instance_private (pan);

  if (!priv->panning)
    {
      if (!guess_direction (pan, offset_x, offset_y, &direction))
        return;

      if (!check_orientation_matches (pan, direction))
        {
          gtk_gesture_set_state (GTK_GESTURE (gesture),
                                 GTK_EVENT_SEQUENCE_DENIED);
          return;
        }

      priv->panning = TRUE;
    }
  else
    direction_from_offset (offset_x, offset_y, priv->orientation, &direction);

  offset = (priv->orientation == GTK_ORIENTATION_VERTICAL) ?
    ABS (offset_y) : ABS (offset_x);
  g_signal_emit (gesture, signals[PAN], 0, direction, offset);
}

static void
gtk_gesture_pan_drag_end (GtkGestureDrag *gesture,
                          gdouble         offset_x,
                          gdouble         offset_y)
{
  GtkGesturePanPrivate *priv;

  priv = gtk_gesture_pan_get_instance_private (GTK_GESTURE_PAN (gesture));
  priv->panning = FALSE;
}

static void
gtk_gesture_pan_class_init (GtkGesturePanClass *klass)
{
  GtkGestureDragClass *drag_gesture_class = GTK_GESTURE_DRAG_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->get_property = gtk_gesture_pan_get_property;
  object_class->set_property = gtk_gesture_pan_set_property;

  drag_gesture_class->drag_update = gtk_gesture_pan_drag_update;
  drag_gesture_class->drag_end = gtk_gesture_pan_drag_end;

  /**
   * GtkGesturePan:orientation:
   *
   * The expected orientation of pan gestures.
   *
   * Since: 3.14
   */
  g_object_class_install_property (object_class,
                                   PROP_ORIENTATION,
                                   g_param_spec_enum ("orientation",
                                                      P_("Orientation"),
                                                      P_("Allowed orientations"),
                                                      GTK_TYPE_ORIENTATION,
                                                      GTK_ORIENTATION_HORIZONTAL,
                                                      GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));

  /**
   * GtkGesturePan::pan:
   * @gesture: The object which received the signal
   * @direction: current direction of the pan gesture
   * @offset: Offset along the gesture orientation
   *
   * This signal is emitted once a panning gesture along the
   * expected axis is detected.
   *
   * Since: 3.14
   */
  signals[PAN] =
    g_signal_new ("pan",
                  G_TYPE_FROM_CLASS (klass),
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (GtkGesturePanClass, pan),
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 2, GTK_TYPE_PAN_DIRECTION,
                  G_TYPE_DOUBLE);
}

static void
gtk_gesture_pan_init (GtkGesturePan *gesture)
{
  GtkGesturePanPrivate *priv;

  priv = gtk_gesture_pan_get_instance_private (gesture);
  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
}

/**
 * gtk_gesture_pan_new:
 * @widget: a #GtkWidget
 * @orientation: expected orientation
 *
 * Returns a newly created #GtkGesture that recognizes pan gestures.
 *
 * Returns: a newly created #GtkGesturePan
 *
 * Since: 3.14
 **/
GtkGesture *
gtk_gesture_pan_new (GtkWidget      *widget,
                     GtkOrientation  orientation)
{
  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);

  return g_object_new (GTK_TYPE_GESTURE_PAN,
                       "widget", widget,
                       "orientation", orientation,
                       NULL);
}

/**
 * gtk_gesture_pan_get_orientation:
 * @gesture: A #GtkGesturePan
 *
 * Returns the orientation of the pan gestures that this @gesture expects.
 *
 * Returns: the expected orientation for pan gestures
 *
 * Since: 3.14
 */
GtkOrientation
gtk_gesture_pan_get_orientation (GtkGesturePan *gesture)
{
  GtkGesturePanPrivate *priv;

  g_return_val_if_fail (GTK_IS_GESTURE_PAN (gesture), 0);

  priv = gtk_gesture_pan_get_instance_private (gesture);

  return priv->orientation;
}

/**
 * gtk_gesture_pan_set_orientation:
 * @gesture: A #GtkGesturePan
 * @orientation: expected orientation
 *
 * Sets the orientation to be expected on pan gestures.
 *
 * Since: 3.14
 */
void
gtk_gesture_pan_set_orientation (GtkGesturePan  *gesture,
                                 GtkOrientation  orientation)
{
  GtkGesturePanPrivate *priv;

  g_return_if_fail (GTK_IS_GESTURE_PAN (gesture));
  g_return_if_fail (orientation == GTK_ORIENTATION_HORIZONTAL ||
                    orientation == GTK_ORIENTATION_VERTICAL);

  priv = gtk_gesture_pan_get_instance_private (gesture);

  if (priv->orientation == orientation)
    return;

  priv->orientation = orientation;
  g_object_notify (G_OBJECT (gesture), "orientation");
}