/*

 * GStreamer

 * Copyright (C) 2014-2015 Jan Schmidt <jan@centricular.com>

 *

 * 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "mviewwidget.h"

G_DEFINE_TYPE (GstMViewWidget, gst_mview_widget, GTK_TYPE_GRID);

static void gst_mview_widget_constructed (GObject * o);

static void gst_mview_widget_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_mview_widget_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

#define DEFAULT_DOWNMIX GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS

enum

{

  PROP_0,

  PROP_IS_OUTPUT,

  PROP_MODE_SELECTOR,

  PROP_FLAGS,

  PROP_DOWNMIX_MODE

};

typedef struct _ToggleClosure

{

  GstMViewWidget *mv;

  GstVideoMultiviewFlags flag;

} ToggleClosure;

static GtkWidget *combo_box_from_enum (GType enum_type);

static void

gst_mview_widget_class_init (GstMViewWidgetClass * klass)

{

  GObjectClass *object_klass = (GObjectClass *) (klass);

  object_klass->constructed = gst_mview_widget_constructed;

  object_klass->set_property = gst_mview_widget_set_property;

  object_klass->get_property = gst_mview_widget_get_property;

  g_object_class_install_property (object_klass, PROP_IS_OUTPUT,

      g_param_spec_boolean ("is-output", "Is an Output widget",

          "TRUE if the widget should have downmix mode", FALSE,

          G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (object_klass, PROP_MODE_SELECTOR,

      g_param_spec_object ("mode-selector", "Multiview Mode selector",

          "Multiview Mode selector widget",

          GTK_TYPE_WIDGET, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (object_klass, PROP_FLAGS,

      g_param_spec_flags ("flags", "Multiview Flags",

          "multiview flags", GST_TYPE_VIDEO_MULTIVIEW_FLAGS,

          GST_VIDEO_MULTIVIEW_FLAGS_NONE,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (object_klass, PROP_DOWNMIX_MODE,

      g_param_spec_enum ("downmix-mode",

          "Mode for mono downmixed output",

          "Output anaglyph type to generate when downmixing to mono",

          GST_TYPE_GL_STEREO_DOWNMIX_MODE_TYPE, DEFAULT_DOWNMIX,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

}

static void

gst_mview_widget_init (GstMViewWidget * mv)

{

}

static void

flag_changed (GObject * w, ToggleClosure * c)

{

  GstMViewWidget *mv = GST_MVIEW_WIDGET (c->mv);

  gboolean flag_set;

  g_object_get (w, "active", &flag_set, NULL);

  if (flag_set)

    mv->flags |= c->flag;

  else

    mv->flags &= ~(c->flag);

  if (!mv->synching)

    g_object_notify (G_OBJECT (mv), "flags");

}

static void

link_button_to_flag (GstMViewWidget * mv, GtkWidget * w,

    GstVideoMultiviewFlags flag)

{

  ToggleClosure *c = g_new0 (ToggleClosure, 1);

  c->mv = mv;

  c->flag = flag;

  g_signal_connect_data (G_OBJECT (w), "toggled", G_CALLBACK (flag_changed),

      c, (GClosureNotify) g_free, 0);

}

static void

sync_flags (GstMViewWidget * mv)

{

  mv->synching = TRUE;

  g_object_set (G_OBJECT (mv->lflip), "active",

      ! !(mv->flags & GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED), NULL);

  g_object_set (G_OBJECT (mv->lflop), "active",

      ! !(mv->flags & GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED), NULL);

  g_object_set (G_OBJECT (mv->rflip), "active",

      ! !(mv->flags & GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED), NULL);

  g_object_set (G_OBJECT (mv->rflop), "active",

      ! !(mv->flags & GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED), NULL);

  g_object_set (G_OBJECT (mv->right_first), "active",

      ! !(mv->flags & GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST), NULL);

  g_object_set (G_OBJECT (mv->half_aspect), "active",

      ! !(mv->flags & GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT), NULL);

  mv->synching = FALSE;

}

static const gchar *

enum_value_to_nick (GType enum_type, guint value)

{

  GEnumClass *enum_info;

  GEnumValue *v;

  const gchar *nick;

  enum_info = (GEnumClass *) (g_type_class_ref (enum_type));

  g_return_val_if_fail (enum_info != NULL, NULL);

  v = g_enum_get_value (enum_info, value);

  g_return_val_if_fail (v != NULL, NULL);

  nick = v->value_nick;

  g_type_class_unref (enum_info);

  return nick;

}

static void

sync_downmix (GstMViewWidget * mv)

{

  mv->synching = TRUE;

  gtk_combo_box_set_active_id (GTK_COMBO_BOX (mv->downmix_combo),

      enum_value_to_nick (GST_TYPE_GL_STEREO_DOWNMIX_MODE_TYPE,

          mv->downmix_mode));

  mv->synching = FALSE;

}

static gboolean

set_downmix_mode (GtkWidget * widget, gpointer data)

{

  GstMViewWidget *mv = GST_MVIEW_WIDGET (data);

  gchar *downmix_mode = NULL;

  GEnumClass *p_class;

  GEnumValue *v;

  GParamSpec *p =

      g_object_class_find_property (G_OBJECT_GET_CLASS (mv), "downmix-mode");

  g_return_val_if_fail (p != NULL, FALSE);

  p_class = G_PARAM_SPEC_ENUM (p)->enum_class;

  g_return_val_if_fail (p_class != NULL, FALSE);

  g_object_get (G_OBJECT (widget), "active-id", &downmix_mode, NULL);

  g_return_val_if_fail (downmix_mode != NULL, FALSE);

  v = g_enum_get_value_by_nick (p_class, downmix_mode);

  g_return_val_if_fail (v != NULL, FALSE);

  mv->downmix_mode = v->value;

  if (!mv->synching)

    g_object_notify (G_OBJECT (mv), "downmix-mode");

  return FALSE;

}

static void

gst_mview_widget_constructed (GObject * o)

{

  GstMViewWidget *mv = GST_MVIEW_WIDGET (o);

  GtkGrid *g = GTK_GRID (mv);

  GtkWidget *w;

  gtk_widget_set_has_window (GTK_WIDGET (mv), FALSE);

  if (mv->is_output) {

    mv->mode_selector = w = combo_box_from_enum (GST_TYPE_VIDEO_MULTIVIEW_MODE);

    gtk_grid_attach (g, gtk_label_new ("Output:"), 0, 0, 1, 1);

  } else {

    mv->mode_selector = w =

        combo_box_from_enum (GST_TYPE_VIDEO_MULTIVIEW_FRAME_PACKING);

    gtk_grid_attach (g, gtk_label_new ("Input:"), 0, 0, 1, 1);

  }

  gtk_grid_attach (g, mv->mode_selector, 1, 0, 3, 1);

  gtk_grid_attach (g, gtk_label_new (" Left "), 4, 0, 1, 1);

  mv->lflip = w = gtk_toggle_button_new_with_label ("Flip");

  link_button_to_flag (mv, w, GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED);

  gtk_grid_attach (g, w, 5, 0, 1, 1);

  mv->lflop = w = gtk_toggle_button_new_with_label ("Flop");

  link_button_to_flag (mv, w, GST_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED);

  gtk_grid_attach (g, w, 6, 0, 1, 1);

  gtk_grid_attach (g, gtk_label_new (" Right "), 4, 1, 1, 1);

  mv->rflip = w = gtk_toggle_button_new_with_label ("Flip");

  link_button_to_flag (mv, w, GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED);

  gtk_grid_attach (g, w, 5, 1, 1, 1);

  mv->rflop = w = gtk_toggle_button_new_with_label ("Flop");

  link_button_to_flag (mv, w, GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED);

  gtk_grid_attach (g, w, 6, 1, 1, 1);

  mv->right_first = w = gtk_toggle_button_new_with_label ("Left/Right swap");

  link_button_to_flag (mv, w, GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST);

  gtk_grid_attach (g, w, 1, 1, 1, 1);

  mv->half_aspect = w = gtk_toggle_button_new_with_label ("Half-Aspect");

  link_button_to_flag (mv, w, GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT);

  gtk_grid_attach (g, w, 2, 1, 1, 1);

  if (mv->is_output) {

    mv->downmix_combo = w =

        combo_box_from_enum (GST_TYPE_GL_STEREO_DOWNMIX_MODE_TYPE);

    gtk_grid_attach (g, w, 1, 2, 3, 1);

    sync_downmix (mv);

    g_signal_connect (G_OBJECT (w), "changed",

        G_CALLBACK (set_downmix_mode), mv);

  }

}

static void

gst_mview_widget_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec)

{

  GstMViewWidget *mv = GST_MVIEW_WIDGET (object);

  switch (prop_id) {

    case PROP_IS_OUTPUT:

      mv->is_output = g_value_get_boolean (value);

      break;

    case PROP_FLAGS:

      mv->flags = (GstVideoMultiviewFlags) g_value_get_flags (value);

      sync_flags (mv);

      break;

    case PROP_DOWNMIX_MODE:

      mv->downmix_mode = g_value_get_enum (value);

      sync_downmix (mv);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_mview_widget_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec)

{

  GstMViewWidget *mv = GST_MVIEW_WIDGET (object);

  switch (prop_id) {

    case PROP_IS_OUTPUT:

      g_value_set_boolean (value, mv->is_output);

      break;

    case PROP_MODE_SELECTOR:

      g_value_set_object (value, mv->mode_selector);

      break;

    case PROP_FLAGS:

      g_value_set_flags (value, mv->flags);

      break;

    case PROP_DOWNMIX_MODE:

      g_value_set_enum (value, mv->downmix_mode);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static GtkWidget *

combo_box_from_enum (GType enum_type)

{

  GEnumClass *enum_info;

  GtkWidget *combo;

  guint i;

  enum_info = (GEnumClass *) (g_type_class_ref (enum_type));

  g_return_val_if_fail (enum_info != NULL, NULL);

  combo = gtk_combo_box_text_new ();

  for (i = 0; i < enum_info->n_values; i++) {

    GEnumValue *v = enum_info->values + i;

    gtk_combo_box_text_insert (GTK_COMBO_BOX_TEXT (combo),

        i, v->value_nick, v->value_name);

  }

  g_type_class_unref (enum_info);

  return combo;

}

GtkWidget *

gst_mview_widget_new (gboolean is_output)

{

  GtkWidget *ret;

  ret = g_object_new (GST_TYPE_MVIEW_WIDGET, "is-output", is_output, NULL);

  return ret;

}