mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-21 20:12:30 +00:00
d6fd55064b
2007-04-25 Michael Natterer <mitch@gimp.org> * app/core/gimpparamspecs.[ch] (struct GimpParamSpecString) (gimp_param_spec_string): added "gboolean non_empty" to require the string being non-empty. Changed validation accordingly. Also fixed validation for static strings (we were happily freeing and modifying them before). * app/xcf/xcf.c: filenames should be non-empty. * app/pdb/gimp-pdb-compat.c: compat strings shouldn't. * tools/pdbgen/app.pl: add support for $arg->{non_empty} and changed generation of calls to gimp_param_spec_string(). * tools/pdbgen/pdb/brush_select.pdb * tools/pdbgen/pdb/edit.pdb * tools/pdbgen/pdb/vectors.pdb * tools/pdbgen/pdb/plug_in.pdb * tools/pdbgen/pdb/gradient.pdb * tools/pdbgen/pdb/palette_select.pdb * tools/pdbgen/pdb/palette.pdb * tools/pdbgen/pdb/fileops.pdb * tools/pdbgen/pdb/progress.pdb * tools/pdbgen/pdb/procedural_db.pdb * tools/pdbgen/pdb/font_select.pdb * tools/pdbgen/pdb/pattern_select.pdb * tools/pdbgen/pdb/unit.pdb * tools/pdbgen/pdb/brush.pdb * tools/pdbgen/pdb/gradient_select.pdb * tools/pdbgen/pdb/buffer.pdb: require non-empty strings for data object names, procedure names, unit strings, PDB data identifiers and buffer names. Removed some manual strlen() checks, all other places just got better error reporting for free (proper validation error instead of unspecific execution error). * app/pdb/*_cmds.c: regenerated. svn path=/trunk/; revision=22329
2795 lines
66 KiB
C
2795 lines
66 KiB
C
/* GIMP - The GNU Image Manipulation Program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <glib-object.h>
|
|
|
|
#include "libgimpbase/gimpbase.h"
|
|
|
|
#include "core-types.h"
|
|
|
|
#include "gimp.h"
|
|
#include "gimpimage.h"
|
|
#include "gimplayer.h"
|
|
#include "gimplayermask.h"
|
|
#include "gimpparamspecs.h"
|
|
#include "gimpselection.h"
|
|
|
|
#include "vectors/gimpvectors.h"
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_INT32
|
|
*/
|
|
|
|
GType
|
|
gimp_int32_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpInt32", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_INT32
|
|
*/
|
|
|
|
static void gimp_param_int32_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_int32_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_int32_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_int32_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecInt32),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_int32_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_INT,
|
|
"GimpParamInt32", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int32_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_INT32;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int32_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_int32 (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
gint minimum,
|
|
gint maximum,
|
|
gint default_value,
|
|
GParamFlags flags)
|
|
{
|
|
GParamSpecInt *ispec;
|
|
|
|
g_return_val_if_fail (minimum >= G_MININT32, NULL);
|
|
g_return_val_if_fail (maximum <= G_MAXINT32, NULL);
|
|
g_return_val_if_fail (default_value >= minimum &&
|
|
default_value <= maximum, NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_INT32,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->minimum = minimum;
|
|
ispec->maximum = maximum;
|
|
ispec->default_value = default_value;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_INT16
|
|
*/
|
|
|
|
GType
|
|
gimp_int16_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpInt16", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_INT16
|
|
*/
|
|
|
|
static void gimp_param_int16_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_int16_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_int16_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_int16_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecInt16),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_int16_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_INT,
|
|
"GimpParamInt16", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int16_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_INT16;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int16_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_int16 (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
gint minimum,
|
|
gint maximum,
|
|
gint default_value,
|
|
GParamFlags flags)
|
|
{
|
|
GParamSpecInt *ispec;
|
|
|
|
g_return_val_if_fail (minimum >= G_MININT16, NULL);
|
|
g_return_val_if_fail (maximum <= G_MAXINT16, NULL);
|
|
g_return_val_if_fail (default_value >= minimum &&
|
|
default_value <= maximum, NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_INT16,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->minimum = minimum;
|
|
ispec->maximum = maximum;
|
|
ispec->default_value = default_value;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_INT8
|
|
*/
|
|
|
|
GType
|
|
gimp_int8_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_UINT, "GimpInt8", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_INT8
|
|
*/
|
|
|
|
static void gimp_param_int8_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_int8_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_int8_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_int8_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecInt8),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_int8_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_UINT,
|
|
"GimpParamInt8", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int8_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_INT8;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int8_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_int8 (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
guint minimum,
|
|
guint maximum,
|
|
guint default_value,
|
|
GParamFlags flags)
|
|
{
|
|
GParamSpecInt *ispec;
|
|
|
|
g_return_val_if_fail (maximum <= G_MAXUINT8, NULL);
|
|
g_return_val_if_fail (default_value >= minimum &&
|
|
default_value <= maximum, NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_INT8,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->minimum = minimum;
|
|
ispec->maximum = maximum;
|
|
ispec->default_value = default_value;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_STRING
|
|
*/
|
|
|
|
static void gimp_param_string_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_string_init (GParamSpec *pspec);
|
|
static gboolean gimp_param_string_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
|
|
GType
|
|
gimp_param_string_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_string_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecString),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_string_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_STRING,
|
|
"GimpParamString", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_string_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = G_TYPE_STRING;
|
|
klass->value_validate = gimp_param_string_validate;
|
|
}
|
|
|
|
static void
|
|
gimp_param_string_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecString *sspec = GIMP_PARAM_SPEC_STRING (pspec);
|
|
|
|
sspec->no_validate = FALSE;
|
|
sspec->null_ok = FALSE;
|
|
sspec->non_empty = FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_string_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpParamSpecString *sspec = GIMP_PARAM_SPEC_STRING (pspec);
|
|
gchar *string = value->data[0].v_pointer;
|
|
|
|
if (string)
|
|
{
|
|
gchar *s;
|
|
|
|
if (sspec->non_empty && ! string[0])
|
|
{
|
|
if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
|
|
g_free (string);
|
|
else
|
|
value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
|
|
|
|
value->data[0].v_pointer = g_strdup ("none");
|
|
return TRUE;
|
|
}
|
|
|
|
if (! sspec->no_validate &&
|
|
! g_utf8_validate (string, -1, (const gchar **) &s))
|
|
{
|
|
if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
|
|
{
|
|
value->data[0].v_pointer = g_strdup (string);
|
|
value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
|
|
string = value->data[0].v_pointer;
|
|
}
|
|
|
|
for (s = string; *s; s++)
|
|
if (*s < ' ')
|
|
*s = '?';
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if (! sspec->null_ok)
|
|
{
|
|
value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
|
|
value->data[0].v_pointer = g_strdup ("");
|
|
return TRUE;
|
|
}
|
|
else if (sspec->non_empty)
|
|
{
|
|
value->data[1].v_uint &= ~G_VALUE_NOCOPY_CONTENTS;
|
|
value->data[0].v_pointer = g_strdup ("none");
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_string (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
gboolean no_validate,
|
|
gboolean null_ok,
|
|
gboolean non_empty,
|
|
const gchar *default_value,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecString *sspec;
|
|
|
|
g_return_val_if_fail (! (null_ok && non_empty), NULL);
|
|
|
|
sspec = g_param_spec_internal (GIMP_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;
|
|
sspec->non_empty = non_empty ? TRUE : FALSE;
|
|
}
|
|
|
|
return G_PARAM_SPEC (sspec);
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_ENUM
|
|
*/
|
|
|
|
static void gimp_param_enum_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_enum_init (GParamSpec *pspec);
|
|
static void gimp_param_enum_finalize (GParamSpec *pspec);
|
|
static gboolean gimp_param_enum_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
|
|
GType
|
|
gimp_param_enum_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_enum_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecEnum),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_enum_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_ENUM,
|
|
"GimpParamEnum", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_enum_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = G_TYPE_ENUM;
|
|
klass->finalize = gimp_param_enum_finalize;
|
|
klass->value_validate = gimp_param_enum_validate;
|
|
}
|
|
|
|
static void
|
|
gimp_param_enum_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecEnum *espec = GIMP_PARAM_SPEC_ENUM (pspec);
|
|
|
|
espec->excluded_values = NULL;
|
|
}
|
|
|
|
static void
|
|
gimp_param_enum_finalize (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecEnum *espec = GIMP_PARAM_SPEC_ENUM (pspec);
|
|
GParamSpecClass *parent_class;
|
|
|
|
parent_class = g_type_class_peek (g_type_parent (GIMP_TYPE_PARAM_ENUM));
|
|
|
|
g_slist_free (espec->excluded_values);
|
|
|
|
parent_class->finalize (pspec);
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_enum_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpParamSpecEnum *espec = GIMP_PARAM_SPEC_ENUM (pspec);
|
|
GParamSpecClass *parent_class;
|
|
GSList *list;
|
|
|
|
parent_class = g_type_class_peek (g_type_parent (GIMP_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 *
|
|
gimp_param_spec_enum (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GType enum_type,
|
|
gint default_value,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecEnum *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 (GIMP_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
|
|
gimp_param_spec_enum_exclude_value (GimpParamSpecEnum *espec,
|
|
gint value)
|
|
{
|
|
g_return_if_fail (GIMP_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));
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_IMAGE_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_image_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpImageID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_IMAGE_ID
|
|
*/
|
|
|
|
static void gimp_param_image_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_image_id_init (GParamSpec *pspec);
|
|
static void gimp_param_image_id_set_default (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gboolean gimp_param_image_id_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gint gimp_param_image_id_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2);
|
|
|
|
GType
|
|
gimp_param_image_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_image_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecImageID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_image_id_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_INT,
|
|
"GimpParamImageID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_image_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_IMAGE_ID;
|
|
klass->value_set_default = gimp_param_image_id_set_default;
|
|
klass->value_validate = gimp_param_image_id_validate;
|
|
klass->values_cmp = gimp_param_image_id_values_cmp;
|
|
}
|
|
|
|
static void
|
|
gimp_param_image_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecImageID *ispec = GIMP_PARAM_SPEC_IMAGE_ID (pspec);
|
|
|
|
ispec->gimp = NULL;
|
|
ispec->none_ok = FALSE;
|
|
}
|
|
|
|
static void
|
|
gimp_param_image_id_set_default (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
value->data[0].v_int = -1;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_image_id_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpParamSpecImageID *ispec = GIMP_PARAM_SPEC_IMAGE_ID (pspec);
|
|
gint image_id = value->data[0].v_int;
|
|
GimpImage *image;
|
|
|
|
if (ispec->none_ok && (image_id == 0 || image_id == -1))
|
|
return FALSE;
|
|
|
|
image = gimp_image_get_by_ID (ispec->gimp, image_id);
|
|
|
|
if (! GIMP_IS_IMAGE (image))
|
|
{
|
|
value->data[0].v_int = -1;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gimp_param_image_id_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2)
|
|
{
|
|
gint image_id1 = value1->data[0].v_int;
|
|
gint image_id2 = value2->data[0].v_int;
|
|
|
|
/* try to return at least *something*, it's useless anyway... */
|
|
|
|
if (image_id1 < image_id2)
|
|
return -1;
|
|
else if (image_id1 > image_id2)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_image_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecImageID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_IMAGE_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpImage *
|
|
gimp_value_get_image (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_IMAGE_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
return gimp_image_get_by_ID (gimp, value->data[0].v_int);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_image (GValue *value,
|
|
GimpImage *image)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_IMAGE_ID (value));
|
|
g_return_if_fail (image == NULL || GIMP_IS_IMAGE (image));
|
|
|
|
value->data[0].v_int = image ? gimp_image_get_ID (image) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_ITEM_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_item_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpItemID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_ITEM_ID
|
|
*/
|
|
|
|
static void gimp_param_item_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_item_id_init (GParamSpec *pspec);
|
|
static void gimp_param_item_id_set_default (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gboolean gimp_param_item_id_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gint gimp_param_item_id_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2);
|
|
|
|
GType
|
|
gimp_param_item_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_item_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecItemID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_item_id_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_INT,
|
|
"GimpParamItemID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_item_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_ITEM_ID;
|
|
klass->value_set_default = gimp_param_item_id_set_default;
|
|
klass->value_validate = gimp_param_item_id_validate;
|
|
klass->values_cmp = gimp_param_item_id_values_cmp;
|
|
}
|
|
|
|
static void
|
|
gimp_param_item_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->gimp = NULL;
|
|
ispec->item_type = GIMP_TYPE_ITEM;
|
|
ispec->none_ok = FALSE;
|
|
}
|
|
|
|
static void
|
|
gimp_param_item_id_set_default (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
value->data[0].v_int = -1;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_item_id_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
gint item_id = value->data[0].v_int;
|
|
GimpItem *item;
|
|
|
|
if (ispec->none_ok && (item_id == 0 || item_id == -1))
|
|
return FALSE;
|
|
|
|
item = gimp_item_get_by_ID (ispec->gimp, item_id);
|
|
|
|
if (! item || ! g_type_is_a (G_TYPE_FROM_INSTANCE (item), ispec->item_type))
|
|
{
|
|
value->data[0].v_int = -1;
|
|
return TRUE;
|
|
}
|
|
else if (gimp_item_is_removed (item))
|
|
{
|
|
value->data[0].v_int = -1;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gimp_param_item_id_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2)
|
|
{
|
|
gint item_id1 = value1->data[0].v_int;
|
|
gint item_id2 = value2->data[0].v_int;
|
|
|
|
/* try to return at least *something*, it's useless anyway... */
|
|
|
|
if (item_id1 < item_id2)
|
|
return -1;
|
|
else if (item_id1 > item_id2)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_item_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
GType item_type,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
g_return_val_if_fail (g_type_is_a (item_type, GIMP_TYPE_ITEM), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_ITEM_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->item_type = item_type;
|
|
ispec->none_ok = none_ok;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpItem *
|
|
gimp_value_get_item (const GValue *value,
|
|
Gimp *gimp,
|
|
GType item_type)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_ITEM_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
g_return_val_if_fail (g_type_is_a (item_type, GIMP_TYPE_ITEM), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! g_type_is_a (G_TYPE_FROM_INSTANCE (item), item_type))
|
|
return NULL;
|
|
|
|
return item;
|
|
}
|
|
|
|
void
|
|
gimp_value_set_item (GValue *value,
|
|
GimpItem *item)
|
|
{
|
|
g_return_if_fail (item == NULL || GIMP_IS_ITEM (item));
|
|
|
|
#ifdef __GNUC__
|
|
#warning FIXME remove hack as soon as bug #375864 is fixed */
|
|
#endif
|
|
|
|
if (GIMP_VALUE_HOLDS_ITEM_ID (value))
|
|
value->data[0].v_int = item ? gimp_item_get_ID (item) : -1;
|
|
|
|
else if (GIMP_VALUE_HOLDS_DRAWABLE_ID (value) &&
|
|
GIMP_IS_DRAWABLE (item))
|
|
gimp_value_set_drawable (value, GIMP_DRAWABLE (item));
|
|
|
|
else if (GIMP_VALUE_HOLDS_LAYER_ID (value) &&
|
|
GIMP_IS_LAYER (item))
|
|
gimp_value_set_layer (value, GIMP_LAYER (item));
|
|
|
|
else if (GIMP_VALUE_HOLDS_CHANNEL_ID (value) &&
|
|
GIMP_IS_CHANNEL (item))
|
|
gimp_value_set_channel (value, GIMP_CHANNEL (item));
|
|
|
|
else if (GIMP_VALUE_HOLDS_LAYER_MASK_ID (value) &&
|
|
GIMP_IS_LAYER_MASK (item))
|
|
gimp_value_set_layer_mask (value, GIMP_LAYER_MASK (item));
|
|
|
|
else if (GIMP_VALUE_HOLDS_SELECTION_ID (value) &&
|
|
GIMP_IS_SELECTION (item))
|
|
gimp_value_set_selection (value, GIMP_SELECTION (item));
|
|
|
|
else if (GIMP_VALUE_HOLDS_VECTORS_ID (value) &&
|
|
GIMP_IS_VECTORS (item))
|
|
gimp_value_set_vectors (value, GIMP_VECTORS (item));
|
|
else
|
|
g_return_if_reached ();
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_DRAWABLE_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_drawable_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpDrawableID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_DRAWABLE_ID
|
|
*/
|
|
|
|
static void gimp_param_drawable_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_drawable_id_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_drawable_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_drawable_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecDrawableID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_drawable_id_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_ITEM_ID,
|
|
"GimpParamDrawableID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_drawable_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_DRAWABLE_ID;
|
|
}
|
|
|
|
static void
|
|
gimp_param_drawable_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->item_type = GIMP_TYPE_DRAWABLE;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_drawable_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_DRAWABLE_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpDrawable *
|
|
gimp_value_get_drawable (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_DRAWABLE_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! GIMP_IS_DRAWABLE (item))
|
|
return NULL;
|
|
|
|
return GIMP_DRAWABLE (item);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_drawable (GValue *value,
|
|
GimpDrawable *drawable)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_DRAWABLE_ID (value));
|
|
g_return_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable));
|
|
|
|
value->data[0].v_int = drawable ? gimp_item_get_ID (GIMP_ITEM (drawable)) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_LAYER_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_layer_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpLayerID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_LAYER_ID
|
|
*/
|
|
|
|
static void gimp_param_layer_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_layer_id_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_layer_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_layer_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecLayerID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_layer_id_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_DRAWABLE_ID,
|
|
"GimpParamLayerID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_layer_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_LAYER_ID;
|
|
}
|
|
|
|
static void
|
|
gimp_param_layer_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->item_type = GIMP_TYPE_LAYER;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_layer_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_LAYER_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpLayer *
|
|
gimp_value_get_layer (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_LAYER_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! GIMP_IS_LAYER (item))
|
|
return NULL;
|
|
|
|
return GIMP_LAYER (item);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_layer (GValue *value,
|
|
GimpLayer *layer)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_LAYER_ID (value));
|
|
g_return_if_fail (layer == NULL || GIMP_IS_LAYER (layer));
|
|
|
|
value->data[0].v_int = layer ? gimp_item_get_ID (GIMP_ITEM (layer)) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_CHANNEL_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_channel_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpChannelID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_CHANNEL_ID
|
|
*/
|
|
|
|
static void gimp_param_channel_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_channel_id_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_channel_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_channel_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecChannelID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_channel_id_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_DRAWABLE_ID,
|
|
"GimpParamChannelID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_channel_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_CHANNEL_ID;
|
|
}
|
|
|
|
static void
|
|
gimp_param_channel_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->item_type = GIMP_TYPE_CHANNEL;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_channel_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_CHANNEL_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpChannel *
|
|
gimp_value_get_channel (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_CHANNEL_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! GIMP_IS_CHANNEL (item))
|
|
return NULL;
|
|
|
|
return GIMP_CHANNEL (item);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_channel (GValue *value,
|
|
GimpChannel *channel)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_CHANNEL_ID (value));
|
|
g_return_if_fail (channel == NULL || GIMP_IS_CHANNEL (channel));
|
|
|
|
value->data[0].v_int = channel ? gimp_item_get_ID (GIMP_ITEM (channel)) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_LAYER_MASK_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_layer_mask_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpLayerMaskID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_LAYER_MASK_ID
|
|
*/
|
|
|
|
static void gimp_param_layer_mask_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_layer_mask_id_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_layer_mask_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_layer_mask_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecLayerMaskID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_layer_mask_id_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_CHANNEL_ID,
|
|
"GimpParamLayerMaskID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_layer_mask_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_LAYER_MASK_ID;
|
|
}
|
|
|
|
static void
|
|
gimp_param_layer_mask_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->item_type = GIMP_TYPE_LAYER_MASK;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_layer_mask_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_LAYER_MASK_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpLayerMask *
|
|
gimp_value_get_layer_mask (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_LAYER_MASK_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! GIMP_IS_LAYER_MASK (item))
|
|
return NULL;
|
|
|
|
return GIMP_LAYER_MASK (item);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_layer_mask (GValue *value,
|
|
GimpLayerMask *layer_mask)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_LAYER_MASK_ID (value));
|
|
g_return_if_fail (layer_mask == NULL || GIMP_IS_LAYER_MASK (layer_mask));
|
|
|
|
value->data[0].v_int = layer_mask ? gimp_item_get_ID (GIMP_ITEM (layer_mask)) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_SELECTION_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_selection_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpSelectionID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_SELECTION_ID
|
|
*/
|
|
|
|
static void gimp_param_selection_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_selection_id_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_selection_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_selection_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecSelectionID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_selection_id_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_CHANNEL_ID,
|
|
"GimpParamSelectionID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_selection_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_SELECTION_ID;
|
|
}
|
|
|
|
static void
|
|
gimp_param_selection_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->item_type = GIMP_TYPE_SELECTION;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_selection_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_SELECTION_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpSelection *
|
|
gimp_value_get_selection (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_SELECTION_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! GIMP_IS_SELECTION (item))
|
|
return NULL;
|
|
|
|
return GIMP_SELECTION (item);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_selection (GValue *value,
|
|
GimpSelection *selection)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_SELECTION_ID (value));
|
|
g_return_if_fail (selection == NULL || GIMP_IS_SELECTION (selection));
|
|
|
|
value->data[0].v_int = selection ? gimp_item_get_ID (GIMP_ITEM (selection)) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_VECTORS_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_vectors_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpVectorsID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_VECTORS_ID
|
|
*/
|
|
|
|
static void gimp_param_vectors_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_vectors_id_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_vectors_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_vectors_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecVectorsID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_vectors_id_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_ITEM_ID,
|
|
"GimpParamVectorsID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_vectors_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_VECTORS_ID;
|
|
}
|
|
|
|
static void
|
|
gimp_param_vectors_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecItemID *ispec = GIMP_PARAM_SPEC_ITEM_ID (pspec);
|
|
|
|
ispec->item_type = GIMP_TYPE_VECTORS;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_vectors_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecItemID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_VECTORS_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpVectors *
|
|
gimp_value_get_vectors (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
GimpItem *item;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_VECTORS_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
item = gimp_item_get_by_ID (gimp, value->data[0].v_int);
|
|
|
|
if (item && ! GIMP_IS_VECTORS (item))
|
|
return NULL;
|
|
|
|
return GIMP_VECTORS (item);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_vectors (GValue *value,
|
|
GimpVectors *vectors)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_VECTORS_ID (value));
|
|
g_return_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors));
|
|
|
|
value->data[0].v_int = vectors ? gimp_item_get_ID (GIMP_ITEM (vectors)) : -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_DISPLAY_ID
|
|
*/
|
|
|
|
GType
|
|
gimp_display_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info = { 0, };
|
|
|
|
type = g_type_register_static (G_TYPE_INT, "GimpDisplayID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_DISPLAY_ID
|
|
*/
|
|
|
|
static void gimp_param_display_id_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_display_id_init (GParamSpec *pspec);
|
|
static void gimp_param_display_id_set_default (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gboolean gimp_param_display_id_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gint gimp_param_display_id_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2);
|
|
|
|
GType
|
|
gimp_param_display_id_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_display_id_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecDisplayID),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_display_id_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_INT,
|
|
"GimpParamDisplayID", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_display_id_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_DISPLAY_ID;
|
|
klass->value_set_default = gimp_param_display_id_set_default;
|
|
klass->value_validate = gimp_param_display_id_validate;
|
|
klass->values_cmp = gimp_param_display_id_values_cmp;
|
|
}
|
|
|
|
static void
|
|
gimp_param_display_id_init (GParamSpec *pspec)
|
|
{
|
|
GimpParamSpecDisplayID *ispec = GIMP_PARAM_SPEC_DISPLAY_ID (pspec);
|
|
|
|
ispec->gimp = NULL;
|
|
ispec->none_ok = FALSE;
|
|
}
|
|
|
|
static void
|
|
gimp_param_display_id_set_default (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
value->data[0].v_int = -1;
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_display_id_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpParamSpecDisplayID *ispec = GIMP_PARAM_SPEC_DISPLAY_ID (pspec);
|
|
gint display_id = value->data[0].v_int;
|
|
GimpObject *display;
|
|
|
|
if (ispec->none_ok && (display_id == 0 || display_id == -1))
|
|
return FALSE;
|
|
|
|
display = gimp_get_display_by_ID (ispec->gimp, display_id);
|
|
|
|
if (! GIMP_IS_OBJECT (display))
|
|
{
|
|
value->data[0].v_int = -1;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gimp_param_display_id_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2)
|
|
{
|
|
gint display_id1 = value1->data[0].v_int;
|
|
gint display_id2 = value2->data[0].v_int;
|
|
|
|
/* try to return at least *something*, it's useless anyway... */
|
|
|
|
if (display_id1 < display_id2)
|
|
return -1;
|
|
else if (display_id1 > display_id2)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_display_id (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
Gimp *gimp,
|
|
gboolean none_ok,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecDisplayID *ispec;
|
|
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
ispec = g_param_spec_internal (GIMP_TYPE_PARAM_DISPLAY_ID,
|
|
name, nick, blurb, flags);
|
|
|
|
ispec->gimp = gimp;
|
|
ispec->none_ok = none_ok ? TRUE : FALSE;
|
|
|
|
return G_PARAM_SPEC (ispec);
|
|
}
|
|
|
|
GimpObject *
|
|
gimp_value_get_display (const GValue *value,
|
|
Gimp *gimp)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_DISPLAY_ID (value), NULL);
|
|
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
|
|
|
|
return gimp_get_display_by_ID (gimp, value->data[0].v_int);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_display (GValue *value,
|
|
GimpObject *display)
|
|
{
|
|
gint id = -1;
|
|
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_DISPLAY_ID (value));
|
|
g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display));
|
|
|
|
if (display)
|
|
g_object_get (display, "id", &id, NULL);
|
|
|
|
value->data[0].v_int = id;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_ARRAY
|
|
*/
|
|
|
|
GimpArray *
|
|
gimp_array_new (const guint8 *data,
|
|
gsize length,
|
|
gboolean static_data)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_val_if_fail ((data == NULL && length == 0) ||
|
|
(data != NULL && length > 0), NULL);
|
|
|
|
array = g_new0 (GimpArray, 1);
|
|
|
|
array->data = static_data ? (guint8 *) data : g_memdup (data, length);
|
|
array->length = length;
|
|
array->static_data = static_data;
|
|
|
|
return array;
|
|
}
|
|
|
|
GimpArray *
|
|
gimp_array_copy (const GimpArray *array)
|
|
{
|
|
if (array)
|
|
return gimp_array_new (array->data, array->length, FALSE);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
gimp_array_free (GimpArray *array)
|
|
{
|
|
if (array)
|
|
{
|
|
if (! array->static_data)
|
|
g_free (array->data);
|
|
|
|
g_free (array);
|
|
}
|
|
}
|
|
|
|
GType
|
|
gimp_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
type = g_boxed_type_register_static ("GimpArray",
|
|
(GBoxedCopyFunc) gimp_array_copy,
|
|
(GBoxedFreeFunc) gimp_array_free);
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_ARRAY
|
|
*/
|
|
|
|
static void gimp_param_array_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_array_init (GParamSpec *pspec);
|
|
static gboolean gimp_param_array_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gint gimp_param_array_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2);
|
|
|
|
GType
|
|
gimp_param_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_array_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecArray),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_array_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_BOXED,
|
|
"GimpParamArray", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_array_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_ARRAY;
|
|
klass->value_validate = gimp_param_array_validate;
|
|
klass->values_cmp = gimp_param_array_values_cmp;
|
|
}
|
|
|
|
static void
|
|
gimp_param_array_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_array_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpArray *array = value->data[0].v_pointer;
|
|
|
|
if (array)
|
|
{
|
|
if ((array->data == NULL && array->length != 0) ||
|
|
(array->data != NULL && array->length == 0))
|
|
{
|
|
g_value_set_boxed (value, NULL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gimp_param_array_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2)
|
|
{
|
|
GimpArray *array1 = value1->data[0].v_pointer;
|
|
GimpArray *array2 = value2->data[0].v_pointer;
|
|
|
|
/* try to return at least *something*, it's useless anyway... */
|
|
|
|
if (! array1)
|
|
return array2 != NULL ? -1 : 0;
|
|
else if (! array2)
|
|
return array1 != NULL ? 1 : 0;
|
|
else if (array1->length < array2->length)
|
|
return -1;
|
|
else if (array1->length > array2->length)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_array (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecArray *array_spec;
|
|
|
|
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_ARRAY,
|
|
name, nick, blurb, flags);
|
|
|
|
return G_PARAM_SPEC (array_spec);
|
|
}
|
|
|
|
static const guint8 *
|
|
gimp_value_get_array (const GValue *value)
|
|
{
|
|
GimpArray *array = value->data[0].v_pointer;
|
|
|
|
if (array)
|
|
return array->data;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static guint8 *
|
|
gimp_value_dup_array (const GValue *value)
|
|
{
|
|
GimpArray *array = value->data[0].v_pointer;
|
|
|
|
if (array)
|
|
return g_memdup (array->data, array->length);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
gimp_value_set_array (GValue *value,
|
|
const guint8 *data,
|
|
gsize length)
|
|
{
|
|
GimpArray *array = gimp_array_new (data, length, FALSE);
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|
|
|
|
static void
|
|
gimp_value_set_static_array (GValue *value,
|
|
const guint8 *data,
|
|
gsize length)
|
|
{
|
|
GimpArray *array = gimp_array_new (data, length, TRUE);
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|
|
|
|
static void
|
|
gimp_value_take_array (GValue *value,
|
|
guint8 *data,
|
|
gsize length)
|
|
{
|
|
GimpArray *array = gimp_array_new (data, length, TRUE);
|
|
|
|
array->static_data = FALSE;
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_INT8_ARRAY
|
|
*/
|
|
|
|
GType
|
|
gimp_int8_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
type = g_boxed_type_register_static ("GimpInt8Array",
|
|
(GBoxedCopyFunc) gimp_array_copy,
|
|
(GBoxedFreeFunc) gimp_array_free);
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_INT8_ARRAY
|
|
*/
|
|
|
|
static void gimp_param_int8_array_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_int8_array_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_int8_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_int8_array_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecArray),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_int8_array_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
|
|
"GimpParamInt8Array", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int8_array_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_INT8_ARRAY;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int8_array_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_int8_array (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecArray *array_spec;
|
|
|
|
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_INT8_ARRAY,
|
|
name, nick, blurb, flags);
|
|
|
|
return G_PARAM_SPEC (array_spec);
|
|
}
|
|
|
|
const guint8 *
|
|
gimp_value_get_int8array (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value), NULL);
|
|
|
|
return gimp_value_get_array (value);
|
|
}
|
|
|
|
guint8 *
|
|
gimp_value_dup_int8array (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value), NULL);
|
|
|
|
return gimp_value_dup_array (value);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_int8array (GValue *value,
|
|
const guint8 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value));
|
|
|
|
gimp_value_set_array (value, data, length);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_static_int8array (GValue *value,
|
|
const guint8 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value));
|
|
|
|
gimp_value_set_static_array (value, data, length);
|
|
}
|
|
|
|
void
|
|
gimp_value_take_int8array (GValue *value,
|
|
guint8 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value));
|
|
|
|
gimp_value_take_array (value, data, length);
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_INT16_ARRAY
|
|
*/
|
|
|
|
GType
|
|
gimp_int16_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
type = g_boxed_type_register_static ("GimpInt16Array",
|
|
(GBoxedCopyFunc) gimp_array_copy,
|
|
(GBoxedFreeFunc) gimp_array_free);
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_INT16_ARRAY
|
|
*/
|
|
|
|
static void gimp_param_int16_array_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_int16_array_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_int16_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_int16_array_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecArray),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_int16_array_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
|
|
"GimpParamInt16Array", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int16_array_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_INT16_ARRAY;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int16_array_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_int16_array (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecArray *array_spec;
|
|
|
|
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_INT16_ARRAY,
|
|
name, nick, blurb, flags);
|
|
|
|
return G_PARAM_SPEC (array_spec);
|
|
}
|
|
|
|
const gint16 *
|
|
gimp_value_get_int16array (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value), NULL);
|
|
|
|
return (const gint16 *) gimp_value_get_array (value);
|
|
}
|
|
|
|
gint16 *
|
|
gimp_value_dup_int16array (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value), NULL);
|
|
|
|
return (gint16 *) gimp_value_dup_array (value);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_int16array (GValue *value,
|
|
const gint16 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value));
|
|
|
|
gimp_value_set_array (value, (const guint8 *) data,
|
|
length * sizeof (gint16));
|
|
}
|
|
|
|
void
|
|
gimp_value_set_static_int16array (GValue *value,
|
|
const gint16 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value));
|
|
|
|
gimp_value_set_static_array (value, (const guint8 *) data,
|
|
length * sizeof (gint16));
|
|
}
|
|
|
|
void
|
|
gimp_value_take_int16array (GValue *value,
|
|
gint16 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value));
|
|
|
|
gimp_value_take_array (value, (guint8 *) data,
|
|
length * sizeof (gint16));
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_INT32_ARRAY
|
|
*/
|
|
|
|
GType
|
|
gimp_int32_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
type = g_boxed_type_register_static ("GimpInt32Array",
|
|
(GBoxedCopyFunc) gimp_array_copy,
|
|
(GBoxedFreeFunc) gimp_array_free);
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_INT32_ARRAY
|
|
*/
|
|
|
|
static void gimp_param_int32_array_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_int32_array_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_int32_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_int32_array_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecArray),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_int32_array_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
|
|
"GimpParamInt32Array", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int32_array_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_INT32_ARRAY;
|
|
}
|
|
|
|
static void
|
|
gimp_param_int32_array_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_int32_array (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecArray *array_spec;
|
|
|
|
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_INT32_ARRAY,
|
|
name, nick, blurb, flags);
|
|
|
|
return G_PARAM_SPEC (array_spec);
|
|
}
|
|
|
|
const gint32 *
|
|
gimp_value_get_int32array (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value), NULL);
|
|
|
|
return (const gint32 *) gimp_value_get_array (value);
|
|
}
|
|
|
|
gint32 *
|
|
gimp_value_dup_int32array (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value), NULL);
|
|
|
|
return (gint32 *) gimp_value_dup_array (value);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_int32array (GValue *value,
|
|
const gint32 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value));
|
|
|
|
gimp_value_set_array (value, (const guint8 *) data,
|
|
length * sizeof (gint32));
|
|
}
|
|
|
|
void
|
|
gimp_value_set_static_int32array (GValue *value,
|
|
const gint32 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value));
|
|
|
|
gimp_value_set_static_array (value, (const guint8 *) data,
|
|
length * sizeof (gint32));
|
|
}
|
|
|
|
void
|
|
gimp_value_take_int32array (GValue *value,
|
|
gint32 *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value));
|
|
|
|
gimp_value_take_array (value, (guint8 *) data,
|
|
length * sizeof (gint32));
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_FLOAT_ARRAY
|
|
*/
|
|
|
|
GType
|
|
gimp_float_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
type = g_boxed_type_register_static ("GimpFloatArray",
|
|
(GBoxedCopyFunc) gimp_array_copy,
|
|
(GBoxedFreeFunc) gimp_array_free);
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_FLOAT_ARRAY
|
|
*/
|
|
|
|
static void gimp_param_float_array_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_float_array_init (GParamSpec *pspec);
|
|
|
|
GType
|
|
gimp_param_float_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_float_array_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecArray),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_float_array_init
|
|
};
|
|
|
|
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
|
|
"GimpParamFloatArray", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_float_array_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_FLOAT_ARRAY;
|
|
}
|
|
|
|
static void
|
|
gimp_param_float_array_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_float_array (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecArray *array_spec;
|
|
|
|
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_FLOAT_ARRAY,
|
|
name, nick, blurb, flags);
|
|
|
|
return G_PARAM_SPEC (array_spec);
|
|
}
|
|
|
|
const gdouble *
|
|
gimp_value_get_floatarray (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), NULL);
|
|
|
|
return (const gdouble *) gimp_value_get_array (value);
|
|
}
|
|
|
|
gdouble *
|
|
gimp_value_dup_floatarray (const GValue *value)
|
|
{
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), NULL);
|
|
|
|
return (gdouble *) gimp_value_dup_array (value);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_floatarray (GValue *value,
|
|
const gdouble *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value));
|
|
|
|
gimp_value_set_array (value, (const guint8 *) data,
|
|
length * sizeof (gdouble));
|
|
}
|
|
|
|
void
|
|
gimp_value_set_static_floatarray (GValue *value,
|
|
const gdouble *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value));
|
|
|
|
gimp_value_set_static_array (value, (const guint8 *) data,
|
|
length * sizeof (gdouble));
|
|
}
|
|
|
|
void
|
|
gimp_value_take_floatarray (GValue *value,
|
|
gdouble *data,
|
|
gsize length)
|
|
{
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value));
|
|
|
|
gimp_value_take_array (value, (guint8 *) data,
|
|
length * sizeof (gdouble));
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_STRING_ARRAY
|
|
*/
|
|
|
|
GimpArray *
|
|
gimp_string_array_new (const gchar **data,
|
|
gsize length,
|
|
gboolean static_data)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_val_if_fail ((data == NULL && length == 0) ||
|
|
(data != NULL && length > 0), NULL);
|
|
|
|
array = g_new0 (GimpArray, 1);
|
|
|
|
if (! static_data)
|
|
{
|
|
gchar **tmp = g_new (gchar *, length);
|
|
gint i;
|
|
|
|
for (i = 0; i < length; i++)
|
|
tmp[i] = g_strdup (data[i]);
|
|
|
|
array->data = (guint8 *) tmp;
|
|
}
|
|
else
|
|
{
|
|
array->data = (guint8 *) data;
|
|
}
|
|
|
|
array->length = length;
|
|
array->static_data = static_data;
|
|
|
|
return array;
|
|
}
|
|
|
|
GimpArray *
|
|
gimp_string_array_copy (const GimpArray *array)
|
|
{
|
|
if (array)
|
|
return gimp_string_array_new ((const gchar **) array->data,
|
|
array->length, FALSE);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
gimp_string_array_free (GimpArray *array)
|
|
{
|
|
if (array)
|
|
{
|
|
if (! array->static_data)
|
|
{
|
|
gchar **tmp = (gchar **) array->data;
|
|
gint i;
|
|
|
|
for (i = 0; i < array->length; i++)
|
|
g_free (tmp[i]);
|
|
|
|
g_free (array->data);
|
|
}
|
|
|
|
g_free (array);
|
|
}
|
|
}
|
|
|
|
GType
|
|
gimp_string_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
type = g_boxed_type_register_static ("GimpStringArray",
|
|
(GBoxedCopyFunc) gimp_string_array_copy,
|
|
(GBoxedFreeFunc) gimp_string_array_free);
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/*
|
|
* GIMP_TYPE_PARAM_STRING_ARRAY
|
|
*/
|
|
|
|
static void gimp_param_string_array_class_init (GParamSpecClass *klass);
|
|
static void gimp_param_string_array_init (GParamSpec *pspec);
|
|
static gboolean gimp_param_string_array_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gint gimp_param_string_array_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2);
|
|
|
|
GType
|
|
gimp_param_string_array_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
|
|
if (! type)
|
|
{
|
|
const GTypeInfo info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) gimp_param_string_array_class_init,
|
|
NULL, NULL,
|
|
sizeof (GimpParamSpecArray),
|
|
0,
|
|
(GInstanceInitFunc) gimp_param_string_array_init
|
|
};
|
|
|
|
type = g_type_register_static (G_TYPE_PARAM_BOXED,
|
|
"GimpParamStringArray", &info, 0);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
gimp_param_string_array_class_init (GParamSpecClass *klass)
|
|
{
|
|
klass->value_type = GIMP_TYPE_STRING_ARRAY;
|
|
klass->value_validate = gimp_param_string_array_validate;
|
|
klass->values_cmp = gimp_param_string_array_values_cmp;
|
|
}
|
|
|
|
static void
|
|
gimp_param_string_array_init (GParamSpec *pspec)
|
|
{
|
|
}
|
|
|
|
static gboolean
|
|
gimp_param_string_array_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
GimpArray *array = value->data[0].v_pointer;
|
|
|
|
if (array)
|
|
{
|
|
if ((array->data == NULL && array->length != 0) ||
|
|
(array->data != NULL && array->length == 0))
|
|
{
|
|
g_value_set_boxed (value, NULL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gimp_param_string_array_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2)
|
|
{
|
|
GimpArray *array1 = value1->data[0].v_pointer;
|
|
GimpArray *array2 = value2->data[0].v_pointer;
|
|
|
|
/* try to return at least *something*, it's useless anyway... */
|
|
|
|
if (! array1)
|
|
return array2 != NULL ? -1 : 0;
|
|
else if (! array2)
|
|
return array1 != NULL ? 1 : 0;
|
|
else if (array1->length < array2->length)
|
|
return -1;
|
|
else if (array1->length > array2->length)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
GParamSpec *
|
|
gimp_param_spec_string_array (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
GParamFlags flags)
|
|
{
|
|
GimpParamSpecStringArray *array_spec;
|
|
|
|
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_STRING_ARRAY,
|
|
name, nick, blurb, flags);
|
|
|
|
return G_PARAM_SPEC (array_spec);
|
|
}
|
|
|
|
const gchar **
|
|
gimp_value_get_stringarray (const GValue *value)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_STRING_ARRAY (value), NULL);
|
|
|
|
array = value->data[0].v_pointer;
|
|
|
|
if (array)
|
|
return (const gchar **) array->data;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
gchar **
|
|
gimp_value_dup_stringarray (const GValue *value)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_val_if_fail (GIMP_VALUE_HOLDS_STRING_ARRAY (value), NULL);
|
|
|
|
array = value->data[0].v_pointer;
|
|
|
|
if (array)
|
|
{
|
|
gchar **ret = g_memdup (array->data, array->length * sizeof (gchar *));
|
|
gint i;
|
|
|
|
for (i = 0; i < array->length; i++)
|
|
ret[i] = g_strdup (ret[i]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
gimp_value_set_stringarray (GValue *value,
|
|
const gchar **data,
|
|
gsize length)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_STRING_ARRAY (value));
|
|
|
|
array = gimp_string_array_new (data, length, FALSE);
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|
|
|
|
void
|
|
gimp_value_set_static_stringarray (GValue *value,
|
|
const gchar **data,
|
|
gsize length)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_STRING_ARRAY (value));
|
|
|
|
array = gimp_string_array_new (data, length, TRUE);
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|
|
|
|
void
|
|
gimp_value_take_stringarray (GValue *value,
|
|
gchar **data,
|
|
gsize length)
|
|
{
|
|
GimpArray *array;
|
|
|
|
g_return_if_fail (GIMP_VALUE_HOLDS_STRING_ARRAY (value));
|
|
|
|
array = gimp_string_array_new ((const gchar **) data, length, TRUE);
|
|
array->static_data = FALSE;
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|