/* This file is part of GEGL

 *

 * GEGL 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 3 of the License, or (at your option) any later version.

 *

 * GEGL 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 GEGL; if not, see <http://www.gnu.org/licenses/>.

 *

 * Copyright 2003 Calvin Williamson

 *           2006 Øyvind Kolås

 *

 * Original contents copied from gimp/app/core/gimpparamspecs.h

 * (c) 1995-2006 Spencer Kimball, Peter Mattis and others.

 */

#include "config.h"

#include <glib.h>

#include <glib-object.h>

#include "gegl-paramspecs.h"

static void       gegl_param_double_class_init (GParamSpecClass *klass);

static void       gegl_param_double_init       (GParamSpec      *pspec);

GType

gegl_param_double_get_type (void)

{

  static GType type = 0;

  if (!type)

    {

      const GTypeInfo info =

      {

        sizeof (GParamSpecClass),

        NULL, NULL,

        (GClassInitFunc) gegl_param_double_class_init,

        NULL, NULL,

        sizeof (GeglParamSpecDouble),

        0,

        (GInstanceInitFunc) gegl_param_double_init

      };

      type = g_type_register_static (G_TYPE_PARAM_DOUBLE,

                                     "GeglParamDouble", &info, 0);

    }

  return type;

}

static void

gegl_param_double_class_init (GParamSpecClass *klass)

{

  klass->value_type     = G_TYPE_DOUBLE;

}

static void

gegl_param_double_init (GParamSpec *pspec)

{

  GParamSpecDouble    *dpspec  = G_PARAM_SPEC_DOUBLE (pspec);

  GeglParamSpecDouble *gdpspec = GEGL_PARAM_SPEC_DOUBLE (pspec);

  gdpspec->ui_minimum = dpspec->minimum;

  gdpspec->ui_maximum = dpspec->maximum;

  gdpspec->ui_gamma   = 1.0;

}

GParamSpec *

gegl_param_spec_double (const gchar *name,

                        const gchar *nick,

                        const gchar *blurb,

                        gdouble      minimum,

                        gdouble      maximum,

                        gdouble      default_value,

                        gdouble      ui_minimum,

                        gdouble      ui_maximum,

                        gdouble      ui_gamma,

                        GParamFlags  flags)

{

  GeglParamSpecDouble *pspec;

  GParamSpecDouble *dspec;

  pspec = g_param_spec_internal (GEGL_TYPE_PARAM_DOUBLE,

                                 name, nick, blurb, flags);

  dspec = G_PARAM_SPEC_DOUBLE (pspec);

  dspec->minimum = minimum;

  dspec->maximum = maximum;

  dspec->default_value = default_value;

  pspec->ui_minimum = ui_minimum;

  pspec->ui_maximum = ui_maximum;

  pspec->ui_gamma   = ui_gamma;

  return G_PARAM_SPEC (pspec);

}

static void       gegl_param_int_class_init (GParamSpecClass *klass);

static void       gegl_param_int_init       (GParamSpec      *pspec);

GType

gegl_param_int_get_type (void)

{

  static GType type = 0;

  if (!type)

    {

      const GTypeInfo info =

      {

        sizeof (GParamSpecClass),

        NULL, NULL,

        (GClassInitFunc) gegl_param_int_class_init,

        NULL, NULL,

        sizeof (GeglParamSpecInt),

        0,

        (GInstanceInitFunc) gegl_param_int_init

      };

      type = g_type_register_static (G_TYPE_PARAM_INT,

                                     "GeglParamint", &info, 0);

    }

  return type;

}

static void

gegl_param_int_class_init (GParamSpecClass *klass)

{

  klass->value_type     = G_TYPE_INT;

}

static void

gegl_param_int_init (GParamSpec *pspec)

{

  GParamSpecInt    *dpspec  = G_PARAM_SPEC_INT (pspec);

  GeglParamSpecInt *gdpspec = GEGL_PARAM_SPEC_INT (pspec);

  gdpspec->ui_minimum = dpspec->minimum;

  gdpspec->ui_maximum = dpspec->maximum;

  gdpspec->ui_gamma = 1.0;

}

GParamSpec *

gegl_param_spec_int (const gchar *name,

                     const gchar *nick,

                     const gchar *blurb,

                     gint         minimum,

                     gint         maximum,

                     gint         default_value,

                     gint         ui_minimum,

                     gint         ui_maximum,

                     gdouble      ui_gamma,

                     GParamFlags  flags)

{

  GeglParamSpecInt *pspec;

  GParamSpecInt *ispec;

  pspec = g_param_spec_internal (GEGL_TYPE_PARAM_INT,

                                 name, nick, blurb, flags);

  ispec = G_PARAM_SPEC_INT (pspec);

  ispec->minimum = minimum;

  ispec->maximum = maximum;

  ispec->default_value = default_value;

  pspec->ui_minimum = ui_minimum;

  pspec->ui_maximum = ui_maximum;

  pspec->ui_gamma = ui_gamma;

  return G_PARAM_SPEC (pspec);

}

/*

 * GEGL_TYPE_PARAM_STRING

 */

static void       gegl_param_string_class_init (GParamSpecClass *klass);

static void       gegl_param_string_init (GParamSpec *pspec);

static gboolean   gegl_param_string_validate (GParamSpec *pspec,

                                              GValue     *value);

GType

gegl_param_string_get_type (void)

{

  static GType type = 0;

  if (!type)

    {

      const GTypeInfo info =

      {

        sizeof (GParamSpecClass),

        NULL,                                          NULL,

        (GClassInitFunc) gegl_param_string_class_init,

        NULL,                                          NULL,

        sizeof (GeglParamSpecString),

        0,

        (GInstanceInitFunc) gegl_param_string_init

      };

      type = g_type_register_static (G_TYPE_PARAM_STRING,

                                     "GeglParamString", &info, 0);

    }

  return type;

}

static void

gegl_param_string_class_init (GParamSpecClass *klass)

{

  klass->value_type     = G_TYPE_STRING;

  klass->value_validate = gegl_param_string_validate;

}

static void

gegl_param_string_init (GParamSpec *pspec)

{

  GeglParamSpecString *sspec = GEGL_PARAM_SPEC_STRING (pspec);

  sspec->no_validate = FALSE;

  sspec->null_ok     = FALSE;

}

static gboolean

gegl_param_string_validate (GParamSpec *pspec,

                            GValue     *value)

{

  GeglParamSpecString *sspec  = GEGL_PARAM_SPEC_STRING (pspec);

  gchar               *string = value->data[0].v_pointer;

  if (string)

    {

      gchar *s;

      if (!sspec->no_validate &&

          !g_utf8_validate (string, -1, (const gchar **) &s))

        {

          for (; *s; s++)

            if (*s < ' ')

              *s = '?';

          return TRUE;

        }

    }

  else if (!sspec->null_ok)

    {

      value->data[0].v_pointer = g_strdup ("");

      return TRUE;

    }

  return FALSE;

}

GParamSpec *

gegl_param_spec_string (const gchar *name,

                        const gchar *nick,

                        const gchar *blurb,

                        gboolean     no_validate,

                        gboolean     null_ok,

                        const gchar *default_value,

                        GParamFlags  flags)

{

  GeglParamSpecString *sspec;

  sspec = g_param_spec_internal (GEGL_TYPE_PARAM_STRING,

                                 name, nick, blurb, flags);

  if (sspec)

    {

      g_free (G_PARAM_SPEC_STRING (sspec)->default_value);

      G_PARAM_SPEC_STRING (sspec)->default_value = g_strdup (default_value);

      sspec->no_validate = no_validate ? TRUE : FALSE;

      sspec->null_ok     = null_ok     ? TRUE : FALSE;

    }

  return G_PARAM_SPEC (sspec);

}

/*

 * GEGL_TYPE_PARAM_FILE_PATH

 */

static void       gegl_param_file_path_class_init (GParamSpecClass *klass);

static void       gegl_param_file_path_init       (GParamSpec *pspec);

static gboolean   gegl_param_file_path_validate   (GParamSpec *pspec,

                                                   GValue     *value);

GType

gegl_param_file_path_get_type (void)

{

  static GType type = 0;

  if (!type)

    {

      const GTypeInfo info =

      {

        sizeof (GParamSpecClass),

        NULL,                                        NULL,

        (GClassInitFunc) gegl_param_file_path_class_init,

        NULL,                                        NULL,

        sizeof (GeglParamSpecString),

        0,

        (GInstanceInitFunc) gegl_param_file_path_init

      };

      type = g_type_register_static (G_TYPE_PARAM_STRING,

                                     "GeglParamFilePath", &info, 0);

    }

  return type;

}

static void

gegl_param_file_path_class_init (GParamSpecClass *klass)

{

  klass->value_type     = G_TYPE_STRING;

  klass->value_validate = gegl_param_file_path_validate;

}

static void

gegl_param_file_path_init (GParamSpec *pspec)

{

  GeglParamSpecFilePath *sspec = GEGL_PARAM_SPEC_FILE_PATH (pspec);

  sspec->no_validate = FALSE;

  sspec->null_ok     = FALSE;

}

static gboolean

gegl_param_file_path_validate (GParamSpec *pspec,

                               GValue     *value)

{

  GeglParamSpecFilePath *sspec = GEGL_PARAM_SPEC_FILE_PATH (pspec);

  gchar                 *path  = value->data[0].v_pointer;

  if (path)

    {

      gchar *s;

      if (!sspec->no_validate &&

          !g_utf8_validate (path, -1, (const gchar **) &s))

        {

          for (; *s; s++)

            if (*s < ' ')

              *s = '?';

          return TRUE;

        }

    }

  else if (!sspec->null_ok)

    {

      value->data[0].v_pointer = g_strdup ("");

      return TRUE;

    }

  return FALSE;

}

GParamSpec *

gegl_param_spec_file_path (const gchar *name,

                           const gchar *nick,

                           const gchar *blurb,

                           gboolean     no_validate,

                           gboolean     null_ok,

                           const gchar *default_value,

                           GParamFlags  flags)

{

  GeglParamSpecFilePath *sspec;

  sspec = g_param_spec_internal (GEGL_TYPE_PARAM_FILE_PATH,

                                 name, nick, blurb, flags);

  if (sspec)

    {

      g_free (G_PARAM_SPEC_STRING (sspec)->default_value);

      G_PARAM_SPEC_STRING (sspec)->default_value = g_strdup (default_value);

      sspec->no_validate = no_validate ? TRUE : FALSE;

      sspec->null_ok     = null_ok     ? TRUE : FALSE;

    }

  return G_PARAM_SPEC (sspec);

}

/*

 * GEGL_TYPE_PARAM_MULTILINE

 */

static void       gegl_param_multiline_class_init (GParamSpecClass *klass);

static void       gegl_param_multiline_init (GParamSpec *pspec);

static gboolean   gegl_param_multiline_validate (GParamSpec *pspec,

                                                 GValue     *value);

GType

gegl_param_multiline_get_type (void)

{

  static GType type = 0;

  if (!type)

    {

      const GTypeInfo info =

      {

        sizeof (GParamSpecClass),

        NULL,                                             NULL,

        (GClassInitFunc) gegl_param_multiline_class_init,

        NULL,                                             NULL,

        sizeof (GeglParamSpecString),

        0,

        (GInstanceInitFunc) gegl_param_multiline_init

      };

      type = g_type_register_static (G_TYPE_PARAM_STRING,

                                     "GeglParamMultiline", &info, 0);

    }

  return type;

}

static void

gegl_param_multiline_class_init (GParamSpecClass *klass)

{

  klass->value_type     = G_TYPE_STRING;

  klass->value_validate = gegl_param_multiline_validate;

}

static void

gegl_param_multiline_init (GParamSpec *pspec)

{

  GeglParamSpecMultiline *sspec = GEGL_PARAM_SPEC_MULTILINE (pspec);

  sspec->no_validate = FALSE;

  sspec->null_ok     = FALSE;

}

static gboolean

gegl_param_multiline_validate (GParamSpec *pspec,

                               GValue     *value)

{

  GeglParamSpecMultiline *sspec     = GEGL_PARAM_SPEC_MULTILINE (pspec);

  gchar                  *multiline = value->data[0].v_pointer;

  if (multiline)

    {

      gchar *s;

      if (!sspec->no_validate &&

          !g_utf8_validate (multiline, -1, (const gchar **) &s))

        {

          for (; *s; s++)

            if (*s < ' ')

              *s = '?';

          return TRUE;

        }

    }

  else if (!sspec->null_ok)

    {

      value->data[0].v_pointer = g_strdup ("");

      return TRUE;

    }

  return FALSE;

}

GParamSpec *

gegl_param_spec_multiline (const gchar *name,

                           const gchar *nick,

                           const gchar *blurb,

                           const gchar *default_value,

                           GParamFlags  flags)

{

  GeglParamSpecMultiline *sspec;

  sspec = g_param_spec_internal (GEGL_TYPE_PARAM_MULTILINE,

                                 name, nick, blurb, flags);

  if (sspec)

    {

      g_free (G_PARAM_SPEC_STRING (sspec)->default_value);

      G_PARAM_SPEC_STRING (sspec)->default_value = g_strdup (default_value);

/*

      sspec->no_validate = no_validate ? TRUE : FALSE;

      sspec->null_ok     = null_ok     ? TRUE : FALSE;*/

    }

  return G_PARAM_SPEC (sspec);

}

/*

 * GEGL_TYPE_PARAM_ENUM

 */

static void       gegl_param_enum_class_init (GParamSpecClass *klass);

static void       gegl_param_enum_init       (GParamSpec      *pspec);

static void       gegl_param_enum_finalize   (GParamSpec      *pspec);

static gboolean   gegl_param_enum_validate   (GParamSpec      *pspec,

                                              GValue          *value);

GType

gegl_param_enum_get_type (void)

{

  static GType type = 0;

  if (!type)

    {

      const GTypeInfo info =

      {

        sizeof (GParamSpecClass),

        NULL,                                        NULL,

        (GClassInitFunc) gegl_param_enum_class_init,

        NULL,                                        NULL,

        sizeof (GeglParamSpecEnum),

        0,

        (GInstanceInitFunc) gegl_param_enum_init

      };

      type = g_type_register_static (G_TYPE_PARAM_ENUM,

                                     "GeglParamEnum", &info, 0);

    }

  return type;

}

static void

gegl_param_enum_class_init (GParamSpecClass *klass)

{

  klass->value_type     = G_TYPE_ENUM;

  klass->finalize       = gegl_param_enum_finalize;

  klass->value_validate = gegl_param_enum_validate;

}

static void

gegl_param_enum_init (GParamSpec *pspec)

{

  GeglParamSpecEnum *espec = GEGL_PARAM_SPEC_ENUM (pspec);

  espec->excluded_values = NULL;

}

static void

gegl_param_enum_finalize (GParamSpec *pspec)

{

  GeglParamSpecEnum *espec = GEGL_PARAM_SPEC_ENUM (pspec);

  GParamSpecClass   *parent_class;

  parent_class = g_type_class_peek (g_type_parent (GEGL_TYPE_PARAM_ENUM));

  g_slist_free (espec->excluded_values);

  parent_class->finalize (pspec);

}

static gboolean

gegl_param_enum_validate (GParamSpec *pspec,

                          GValue     *value)

{

  GeglParamSpecEnum *espec = GEGL_PARAM_SPEC_ENUM (pspec);

  GParamSpecClass   *parent_class;

  GSList            *list;

  parent_class = g_type_class_peek (g_type_parent (GEGL_TYPE_PARAM_ENUM));

  if (parent_class->value_validate (pspec, value))

    return TRUE;

  for (list = espec->excluded_values; list; list = g_slist_next (list))

    {

      if (GPOINTER_TO_INT (list->data) == value->data[0].v_long)

        {

          value->data[0].v_long = G_PARAM_SPEC_ENUM (pspec)->default_value;

          return TRUE;

        }

    }

  return FALSE;

}

GParamSpec *

gegl_param_spec_enum (const gchar *name,

                      const gchar *nick,

                      const gchar *blurb,

                      GType        enum_type,

                      gint         default_value,

                      GParamFlags  flags)

{

  GeglParamSpecEnum *espec;

  GEnumClass        *enum_class;

  g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);

  enum_class = g_type_class_ref (enum_type);

  g_return_val_if_fail (g_enum_get_value (enum_class, default_value) != NULL,

                        NULL);

  espec = g_param_spec_internal (GEGL_TYPE_PARAM_ENUM,

                                 name, nick, blurb, flags);

  G_PARAM_SPEC_ENUM (espec)->enum_class    = enum_class;

  G_PARAM_SPEC_ENUM (espec)->default_value = default_value;

  G_PARAM_SPEC (espec)->value_type         = enum_type;

  return G_PARAM_SPEC (espec);

}

void

gegl_param_spec_enum_exclude_value (GeglParamSpecEnum *espec,

                                    gint               value)

{

  g_return_if_fail (GEGL_IS_PARAM_SPEC_ENUM (espec));

  g_return_if_fail (g_enum_get_value (G_PARAM_SPEC_ENUM (espec)->enum_class,

                                      value) != NULL);

  espec->excluded_values = g_slist_prepend (espec->excluded_values,

                                            GINT_TO_POINTER (value));

}