/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
 * 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.
 * Boston, MA 02111-1307, USA.
 *
 */

/**
 * SECTION:mx-gtk-light-switch
 * @short_description: a toggle switch between two states
 *
 * A visual representation of a toggle switch that can move between two states.
 */

#include <config.h>
#include "mx-gtk-light-switch.h"

#include <glib/gi18n-lib.h>

#if 0
/* We use the special gcc constructor attribute so we can avoid
 * requiring an init function to get translations to work! This
 * function is also in mx-utils but we also need it here
 * because that is a separate library */
static void __attribute__ ((constructor))
_start (void)
{
  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
}
#endif

G_DEFINE_TYPE (MxGtkLightSwitch, mx_gtk_light_switch, GTK_TYPE_DRAWING_AREA)

#define MX_GTK_LIGHT_SWITCH_GET_PRIVATE(o)                                 \
  (G_TYPE_INSTANCE_GET_PRIVATE ((o), MX_GTK_TYPE_LIGHT_SWITCH, MxGtkLightSwitchPrivate))

static gboolean mx_gtk_light_switch_configure (GtkWidget         *lightswitch,
                                               GdkEventConfigure *event);
static gboolean mx_gtk_light_switch_expose (GtkWidget      *lightswitch,
                                            GdkEventExpose *event);
static gboolean mx_gtk_light_switch_button_release (GtkWidget      *lightswitch,
                                                    GdkEventButton *event);
static gboolean mx_gtk_light_switch_button_press (GtkWidget      *lightswitch,
                                                  GdkEventButton *event);
static gboolean mx_gtk_light_switch_motion_notify (GtkWidget      *lightswitch,
                                                   GdkEventMotion *event);
static void mx_gtk_light_switch_size_request (GtkWidget      *lightswitch,
                                              GtkRequisition *req);

static void mx_gtk_light_switch_style_set (GtkWidget *lightswitch,
                                           GtkStyle  *previous_style);

enum {
  SWITCH_FLIPPED,
  LAST_SIGNAL
};

static guint mx_gtk_light_switch_signals[LAST_SIGNAL] = { 0 };

enum {
  PROP_0,
  PROP_ACTIVE,
};

typedef struct _MxGtkLightSwitchPrivate MxGtkLightSwitchPrivate;

struct _MxGtkLightSwitchPrivate {
  gboolean active; /* boolean state of switch */
  gboolean dragging; /* true if dragging switch */
  gint     x; /* the x position of the switch */
  gint     drag_start; /* position dragging started at */
  gint     drag_threshold;
  gint     switch_width;
  gint     switch_height;
  gint     trough_width;
  gint     offset; /* offset of the mouse to slider when dragging */
};

#define ON_STRING _("On")
#define OFF_STRING _("Off")

#define UNAVAILABLE_STRING _("Unavailable")

static void
mx_gtk_light_switch_set_property (GObject      *object,
                                  guint         prop_id,
                                  const GValue *value,
                                  GParamSpec   *pspec)
{
  MxGtkLightSwitch *ls;

  ls = MX_GTK_LIGHT_SWITCH (object);

  switch (prop_id)
    {
    case PROP_ACTIVE:
      mx_gtk_light_switch_set_active (ls, g_value_get_boolean (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

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

  priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (object);

  switch (prop_id)
    {
    case PROP_ACTIVE:
      g_value_set_boolean (value, priv->active);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
mx_gtk_light_switch_class_init (MxGtkLightSwitchClass *klass)
{
  GObjectClass *object_class;
  GtkWidgetClass *widget_class;
  GParamSpec *spec;

  object_class = G_OBJECT_CLASS (klass);
  widget_class = GTK_WIDGET_CLASS (klass);

  object_class->set_property = mx_gtk_light_switch_set_property;
  object_class->get_property = mx_gtk_light_switch_get_property;

  widget_class->configure_event = mx_gtk_light_switch_configure;
  widget_class->expose_event = mx_gtk_light_switch_expose;
  widget_class->button_release_event = mx_gtk_light_switch_button_release;
  widget_class->button_press_event = mx_gtk_light_switch_button_press;
  widget_class->motion_notify_event = mx_gtk_light_switch_motion_notify;
  widget_class->size_request = mx_gtk_light_switch_size_request;
  widget_class->style_set = mx_gtk_light_switch_style_set;

  spec = g_param_spec_boolean ("active",
                               "Active",
                               "Is the light switch on or not",
                               FALSE,
                               G_PARAM_READWRITE);
  g_object_class_install_property (object_class, PROP_ACTIVE, spec);

  /* MxGtkLightSwitch signals */
  mx_gtk_light_switch_signals[SWITCH_FLIPPED] =
    g_signal_new ("switch-flipped",
                  G_OBJECT_CLASS_TYPE (object_class),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (MxGtkLightSwitchClass, switch_flipped),
                  NULL, NULL,
                  g_cclosure_marshal_VOID__BOOLEAN,
                  G_TYPE_NONE, 1,
                  G_TYPE_BOOLEAN);

  g_type_class_add_private (klass,
                            sizeof (MxGtkLightSwitchPrivate));
}

static void
mx_gtk_light_switch_init (MxGtkLightSwitch *self)
{
  MxGtkLightSwitchPrivate *priv;

  priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (self);
  priv->active = FALSE;
  priv->x = 0;

  /* add events, do initial draw/update, etc */
  gtk_widget_add_events (GTK_WIDGET (self),
                         GDK_BUTTON_PRESS_MASK
                         | GDK_BUTTON_RELEASE_MASK
                         | GDK_POINTER_MOTION_MASK);
}

static void
draw (GtkWidget *lightswitch,
      cairo_t   *cr)
{
  MxGtkLightSwitchPrivate *priv;

  gint on_label_x;
  gint off_label_x;
  gint label_width;
  gint label_height;
  GtkStyle *style;
  PangoLayout *layout;
  PangoContext *context;
  GtkStateType state_type;

  priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);
  style = lightswitch->style;
#if GTK_CHECK_VERSION (2,19,5)
  state_type = gtk_widget_get_state (lightswitch);
#else
  state_type = GTK_WIDGET_STATE (lightswitch);
#endif

  on_label_x = (priv->trough_width / 5) * 0.75;
  off_label_x = (priv->trough_width / 8) * 5;

  /* draw the trough */
  gtk_paint_box (style,
                 lightswitch->window,
                 (state_type != GTK_STATE_INSENSITIVE && priv->active)
                 ? GTK_STATE_SELECTED : state_type,
                 GTK_SHADOW_IN,
                 NULL,
                 NULL,
                 "light-switch-trough",
                 0,
                 0,
                 (priv->trough_width),
                 priv->switch_height);

#if 0
  if (state_type == GTK_STATE_INSENSITIVE)
    return;
#else
  if (state_type == GTK_STATE_INSENSITIVE)
    {
      context = gdk_pango_context_get ();
      layout = pango_layout_new (context);
      g_object_unref (context);

      pango_layout_set_font_description (layout, style->font_desc);
      pango_layout_set_text (layout, UNAVAILABLE_STRING, -1);
      pango_layout_get_size (layout, &label_width, &label_height);
      gtk_paint_layout (style, lightswitch->window, state_type, FALSE,
                        NULL, lightswitch, "lighswitch-label",
                        (priv->trough_width - (label_width / PANGO_SCALE)) / 2,
                        (priv->switch_height - (label_height / PANGO_SCALE)) / 2,
                        layout);
      g_object_unref (layout);
      return;
    }

  /* Draw the first label; "On" */
  context = gdk_pango_context_get ();
  layout = pango_layout_new (context);
  g_object_unref (context);
  pango_layout_set_font_description (layout,
                                     style->font_desc);
  pango_layout_set_text (layout, ON_STRING, -1);
  pango_layout_get_size (layout,
                         &label_width,
                         &label_height);
  gtk_paint_layout (style,
                    lightswitch->window,
                    (priv->active) ? GTK_STATE_SELECTED : GTK_STATE_NORMAL,
                    FALSE,
                    NULL,
                    (GtkWidget*) lightswitch,
                    "lightswitch-label",
                    on_label_x,
                    (priv->switch_height
                     - (label_height / PANGO_SCALE)) / 2,
                    layout);

  pango_layout_set_text (layout, OFF_STRING, -1);
  pango_layout_get_size (layout,
                         &label_width,
                         &label_height);
  gtk_paint_layout (style,
                    lightswitch->window,
                    (priv->active) ? GTK_STATE_SELECTED : GTK_STATE_NORMAL,
                    FALSE,
                    NULL,
                    (GtkWidget*) lightswitch,
                    "lightswitch-label",
                    off_label_x,
                    (priv->switch_height
                     - (label_height / PANGO_SCALE)) / 2,
                    layout);
  g_object_unref (layout);
#endif
  /* draw the switch itself */
  gtk_paint_box (style,
                 lightswitch->window,
#if GTK_CHECK_VERSION (2,19,5)
                 gtk_widget_get_state (lightswitch),
#else
                 GTK_WIDGET_STATE (lightswitch),
#endif
                 GTK_SHADOW_OUT,
                 NULL,
                 NULL,
                 "light-switch-handle",
                 priv->x + style->xthickness,
                 style->ythickness,
                 priv->switch_width - style->xthickness * 2,
                 priv->switch_height - style->ythickness * 2);

}

static void
mx_gtk_light_switch_size_request (GtkWidget      *lightswitch,
                                  GtkRequisition *req)
{
  MxGtkLightSwitchPrivate *priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  req->height = priv->switch_height;
  req->width = priv->trough_width;
}

static void
mx_gtk_light_switch_style_set (GtkWidget *lightswitch,
                               GtkStyle  *previous_style)
{
  MxGtkLightSwitchPrivate *priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);
  PangoLayout *layout;
  gint label_width, label_height;

  layout = gtk_widget_create_pango_layout (GTK_WIDGET (lightswitch), NULL);
  pango_layout_set_text (layout, UNAVAILABLE_STRING, -1);
  pango_layout_get_pixel_size (layout, &label_width, &label_height);
  g_object_unref (layout);

  /* MxToggle is 105x39, so make sure light-switch is at least this size */
  priv->trough_width = MAX (103, label_width);
  priv->switch_width = (priv->trough_width / 2) * 1.1;
  //priv->switch_height = MAX (39, label_height);
  priv->switch_height = 24;
  priv->switch_width = 50;
  priv->trough_width = 98;
}

static gboolean
mx_gtk_light_switch_configure (GtkWidget         *lightswitch,
                               GdkEventConfigure *event)
{
  MxGtkLightSwitchPrivate *priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  if (priv->active)
    priv->x = priv->trough_width - priv->switch_width;
  else
    priv->x = 0;

  return FALSE;
}

static gboolean
mx_gtk_light_switch_expose (GtkWidget      *lightswitch,
                            GdkEventExpose *event)
{
  cairo_t *cr;
  cr = gdk_cairo_create (lightswitch->window);

  cairo_rectangle (cr,
                   event->area.x,
                   event->area.y,
                   event->area.width,
                   event->area.height);

  cairo_clip (cr);

  draw (lightswitch, cr);

  cairo_destroy (cr);

  return FALSE;
}

static gboolean
mx_gtk_light_switch_motion_notify (GtkWidget      *lightswitch,
                                   GdkEventMotion *event)
{
  MxGtkLightSwitchPrivate *priv;

  priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  if (ABS (event->x - priv->drag_start) < priv->drag_threshold)
    return TRUE;

  if (event->state & GDK_BUTTON1_MASK)
    {
      gint position = event->x - priv->offset;

      if (position > (priv->trough_width - priv->switch_width))
        priv->x = (priv->trough_width - priv->switch_width);
      else if (position < 0)
        priv->x = 0;
      else
        priv->x = position;

      priv->dragging = TRUE;
      gtk_widget_queue_draw ((GtkWidget *) lightswitch);
    }

  return TRUE;
}

/**
 * mx_gtk_light_switch_get_active:
 * @lightswitch: A #MxGtkLightSwitch
 *
 * Get the value of the "active" property
 *
 * Returns: #TRUE if the switch is "on"
 */
gboolean
mx_gtk_light_switch_get_active (MxGtkLightSwitch *lightswitch)
{
  MxGtkLightSwitchPrivate *priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  return priv->active;
}

/**
 * mx_gtk_light_switch_set_active:
 * @lightswitch: A #MxGtkLightSwitch
 * @active: #TRUE to set the switch to its ON state
 *
 * Set the value of the "active" property
 *
 */
void
mx_gtk_light_switch_set_active (MxGtkLightSwitch *lightswitch,
                                gboolean          active)
{
  MxGtkLightSwitchPrivate *priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  if (priv->active == active)
    {
      return;
    }
  else
    {
      priv->active = active;
      if (active == TRUE)
        {
          priv->x = priv->trough_width - priv->switch_width;
        }
      else
        {
          priv->x = 0;
        }

      gtk_widget_queue_draw ((GtkWidget *) lightswitch);

      g_object_notify (G_OBJECT (lightswitch), "active");
      g_signal_emit (lightswitch,
                     mx_gtk_light_switch_signals[SWITCH_FLIPPED],
                     0,
                     priv->active);
    }
}

static gboolean
mx_gtk_light_switch_button_press (GtkWidget      *lightswitch,
                                  GdkEventButton *event)
{
  MxGtkLightSwitchPrivate *priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  if (priv->active)
    priv->offset = event->x - (priv->trough_width - priv->switch_width);
  else
    priv->offset = event->x;

  priv->drag_start = event->x;

  g_object_get (gtk_widget_get_settings (lightswitch),
                "gtk-dnd-drag-threshold", &priv->drag_threshold,
                NULL);

  return FALSE;
}

static gboolean
mx_gtk_light_switch_button_release (GtkWidget      *lightswitch,
                                    GdkEventButton *event)
{
  MxGtkLightSwitchPrivate *priv;

  priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);

  /* detect whereabouts we are and "drop" into a state */
  if (priv->dragging)
    {
      priv->dragging = FALSE;
      if (priv->x + (priv->switch_width / 2) > priv->trough_width / 2)
        {
          mx_gtk_light_switch_set_active ((MxGtkLightSwitch *) lightswitch, TRUE);
          priv->x = priv->trough_width - priv->switch_width;
        }
      else
        {
          mx_gtk_light_switch_set_active ((MxGtkLightSwitch *) lightswitch, FALSE);
          priv->x = 0;
        }
      /* we always need to queue a redraw after dragging to put the slider back
       * in the correct place */
      gtk_widget_queue_draw ((GtkWidget *) lightswitch);
    }
  else
    {
      mx_gtk_light_switch_set_active ((MxGtkLightSwitch *) lightswitch, !priv->active);
    }

  return FALSE;
}

/**
 * mx_gtk_light_switch_new:
 *
 * Create a #MxGtkLightSwitch
 *
 * Returns: a newly allocated #MxGtkLightSwitch
 */
GtkWidget*
mx_gtk_light_switch_new (void)
{
  return g_object_new (MX_GTK_TYPE_LIGHT_SWITCH, NULL);
}