Parameters and Values

Parameters and Values — Standard Parameter and Value Types

Synopsis


#include <glib-object.h>

#define             G_IS_PARAM_SPEC_BOOLEAN             (pspec)
#define             G_PARAM_SPEC_BOOLEAN                (pspec)
#define             G_VALUE_HOLDS_BOOLEAN               (value)
#define             G_TYPE_PARAM_BOOLEAN
                    GParamSpecBoolean;
GParamSpec*         g_param_spec_boolean                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gboolean default_value,
                                                         GParamFlags flags);
void                g_value_set_boolean                 (GValue *value,
                                                         gboolean v_boolean);
gboolean            g_value_get_boolean                 (const GValue *value);

#define             G_IS_PARAM_SPEC_CHAR                (pspec)
#define             G_PARAM_SPEC_CHAR                   (pspec)
#define             G_VALUE_HOLDS_CHAR                  (value)
#define             G_TYPE_PARAM_CHAR
                    GParamSpecChar;
GParamSpec*         g_param_spec_char                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint8 minimum,
                                                         gint8 maximum,
                                                         gint8 default_value,
                                                         GParamFlags flags);
void                g_value_set_char                    (GValue *value,
                                                         gchar v_char);
gchar               g_value_get_char                    (const GValue *value);

#define             G_IS_PARAM_SPEC_UCHAR               (pspec)
#define             G_PARAM_SPEC_UCHAR                  (pspec)
#define             G_VALUE_HOLDS_UCHAR                 (value)
#define             G_TYPE_PARAM_UCHAR
                    GParamSpecUChar;
GParamSpec*         g_param_spec_uchar                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint8 minimum,
                                                         guint8 maximum,
                                                         guint8 default_value,
                                                         GParamFlags flags);
void                g_value_set_uchar                   (GValue *value,
                                                         guchar v_uchar);
guchar              g_value_get_uchar                   (const GValue *value);

#define             G_IS_PARAM_SPEC_INT                 (pspec)
#define             G_PARAM_SPEC_INT                    (pspec)
#define             G_VALUE_HOLDS_INT                   (value)
#define             G_TYPE_PARAM_INT
                    GParamSpecInt;
GParamSpec*         g_param_spec_int                    (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint minimum,
                                                         gint maximum,
                                                         gint default_value,
                                                         GParamFlags flags);
void                g_value_set_int                     (GValue *value,
                                                         gint v_int);
gint                g_value_get_int                     (const GValue *value);

#define             G_IS_PARAM_SPEC_UINT                (pspec)
#define             G_PARAM_SPEC_UINT                   (pspec)
#define             G_VALUE_HOLDS_UINT                  (value)
#define             G_TYPE_PARAM_UINT
                    GParamSpecUInt;
GParamSpec*         g_param_spec_uint                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint minimum,
                                                         guint maximum,
                                                         guint default_value,
                                                         GParamFlags flags);
void                g_value_set_uint                    (GValue *value,
                                                         guint v_uint);
guint               g_value_get_uint                    (const GValue *value);

#define             G_IS_PARAM_SPEC_LONG                (pspec)
#define             G_PARAM_SPEC_LONG                   (pspec)
#define             G_VALUE_HOLDS_LONG                  (value)
#define             G_TYPE_PARAM_LONG
                    GParamSpecLong;
GParamSpec*         g_param_spec_long                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         glong minimum,
                                                         glong maximum,
                                                         glong default_value,
                                                         GParamFlags flags);
void                g_value_set_long                    (GValue *value,
                                                         glong v_long);
glong               g_value_get_long                    (const GValue *value);

#define             G_IS_PARAM_SPEC_ULONG               (pspec)
#define             G_PARAM_SPEC_ULONG                  (pspec)
#define             G_VALUE_HOLDS_ULONG                 (value)
#define             G_TYPE_PARAM_ULONG
                    GParamSpecULong;
GParamSpec*         g_param_spec_ulong                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gulong minimum,
                                                         gulong maximum,
                                                         gulong default_value,
                                                         GParamFlags flags);
void                g_value_set_ulong                   (GValue *value,
                                                         gulong v_ulong);
gulong              g_value_get_ulong                   (const GValue *value);

#define             G_IS_PARAM_SPEC_INT64               (pspec)
#define             G_PARAM_SPEC_INT64                  (pspec)
#define             G_VALUE_HOLDS_INT64                 (value)
#define             G_TYPE_PARAM_INT64
                    GParamSpecInt64;
GParamSpec*         g_param_spec_int64                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint64 minimum,
                                                         gint64 maximum,
                                                         gint64 default_value,
                                                         GParamFlags flags);
void                g_value_set_int64                   (GValue *value,
                                                         gint64 v_int64);
gint64              g_value_get_int64                   (const GValue *value);

#define             G_IS_PARAM_SPEC_UINT64              (pspec)
#define             G_PARAM_SPEC_UINT64                 (pspec)
#define             G_VALUE_HOLDS_UINT64                (value)
#define             G_TYPE_PARAM_UINT64
                    GParamSpecUInt64;
GParamSpec*         g_param_spec_uint64                 (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint64 minimum,
                                                         guint64 maximum,
                                                         guint64 default_value,
                                                         GParamFlags flags);
void                g_value_set_uint64                  (GValue *value,
                                                         guint64 v_uint64);
guint64             g_value_get_uint64                  (const GValue *value);

#define             G_IS_PARAM_SPEC_FLOAT               (pspec)
#define             G_PARAM_SPEC_FLOAT                  (pspec)
#define             G_VALUE_HOLDS_FLOAT                 (value)
#define             G_TYPE_PARAM_FLOAT
                    GParamSpecFloat;
GParamSpec*         g_param_spec_float                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gfloat minimum,
                                                         gfloat maximum,
                                                         gfloat default_value,
                                                         GParamFlags flags);
void                g_value_set_float                   (GValue *value,
                                                         gfloat v_float);
gfloat              g_value_get_float                   (const GValue *value);

#define             G_IS_PARAM_SPEC_DOUBLE              (pspec)
#define             G_PARAM_SPEC_DOUBLE                 (pspec)
#define             G_VALUE_HOLDS_DOUBLE                (value)
#define             G_TYPE_PARAM_DOUBLE
                    GParamSpecDouble;
GParamSpec*         g_param_spec_double                 (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gdouble minimum,
                                                         gdouble maximum,
                                                         gdouble default_value,
                                                         GParamFlags flags);
void                g_value_set_double                  (GValue *value,
                                                         gdouble v_double);
gdouble             g_value_get_double                  (const GValue *value);

#define             G_IS_PARAM_SPEC_ENUM                (pspec)
#define             G_PARAM_SPEC_ENUM                   (pspec)
#define             G_VALUE_HOLDS_ENUM                  (value)
#define             G_TYPE_PARAM_ENUM
                    GParamSpecEnum;
GParamSpec*         g_param_spec_enum                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType enum_type,
                                                         gint default_value,
                                                         GParamFlags flags);
void                g_value_set_enum                    (GValue *value,
                                                         gint v_enum);
gint                g_value_get_enum                    (const GValue *value);

#define             G_IS_PARAM_SPEC_FLAGS               (pspec)
#define             G_PARAM_SPEC_FLAGS                  (pspec)
#define             G_VALUE_HOLDS_FLAGS                 (value)
#define             G_TYPE_PARAM_FLAGS
                    GParamSpecFlags;
GParamSpec*         g_param_spec_flags                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType flags_type,
                                                         guint default_value,
                                                         GParamFlags flags);
void                g_value_set_flags                   (GValue *value,
                                                         guint v_flags);
guint               g_value_get_flags                   (const GValue *value);

#define             G_IS_PARAM_SPEC_STRING              (pspec)
#define             G_PARAM_SPEC_STRING                 (pspec)
#define             G_VALUE_HOLDS_STRING                (value)
#define             G_TYPE_PARAM_STRING
                    GParamSpecString;
typedef             gchararray;
GParamSpec*         g_param_spec_string                 (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         const gchar *default_value,
                                                         GParamFlags flags);
void                g_value_set_string                  (GValue *value,
                                                         const gchar *v_string);
void                g_value_set_static_string           (GValue *value,
                                                         const gchar *v_string);
void                g_value_take_string                 (GValue *value,
                                                         gchar *v_string);
void                g_value_set_string_take_ownership   (GValue *value,
                                                         gchar *v_string);
const gchar*        g_value_get_string                  (const GValue *value);
gchar*              g_value_dup_string                  (const GValue *value);

#define             G_IS_PARAM_SPEC_PARAM               (pspec)
#define             G_PARAM_SPEC_PARAM                  (pspec)
#define             G_VALUE_HOLDS_PARAM                 (value)
#define             G_TYPE_PARAM_PARAM
                    GParamSpecParam;
GParamSpec*         g_param_spec_param                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType param_type,
                                                         GParamFlags flags);
void                g_value_set_param                   (GValue *value,
                                                         GParamSpec *param);
void                g_value_take_param                  (GValue *value,
                                                         GParamSpec *param);
void                g_value_set_param_take_ownership    (GValue *value,
                                                         GParamSpec *param);
GParamSpec*         g_value_get_param                   (const GValue *value);
GParamSpec*         g_value_dup_param                   (const GValue *value);

#define             G_IS_PARAM_SPEC_BOXED               (pspec)
#define             G_PARAM_SPEC_BOXED                  (pspec)
#define             G_VALUE_HOLDS_BOXED                 (value)
#define             G_TYPE_PARAM_BOXED
                    GParamSpecBoxed;
GParamSpec*         g_param_spec_boxed                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType boxed_type,
                                                         GParamFlags flags);
void                g_value_set_boxed                   (GValue *value,
                                                         gconstpointer v_boxed);
void                g_value_set_static_boxed            (GValue *value,
                                                         gconstpointer v_boxed);
void                g_value_take_boxed                  (GValue *value,
                                                         gconstpointer v_boxed);
void                g_value_set_boxed_take_ownership    (GValue *value,
                                                         gconstpointer v_boxed);
gpointer            g_value_get_boxed                   (const GValue *value);
gpointer            g_value_dup_boxed                   (const GValue *value);

#define             G_IS_PARAM_SPEC_POINTER             (pspec)
#define             G_PARAM_SPEC_POINTER                (pspec)
#define             G_VALUE_HOLDS_POINTER               (value)
#define             G_TYPE_PARAM_POINTER
                    GParamSpecPointer;
GParamSpec*         g_param_spec_pointer                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
void                g_value_set_pointer                 (GValue *value,
                                                         gpointer v_pointer);
gpointer            g_value_get_pointer                 (const GValue *value);

#define             G_IS_PARAM_SPEC_OBJECT              (pspec)
#define             G_PARAM_SPEC_OBJECT                 (pspec)
#define             G_VALUE_HOLDS_OBJECT                (value)
#define             G_TYPE_PARAM_OBJECT
                    GParamSpecObject;
GParamSpec*         g_param_spec_object                 (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType object_type,
                                                         GParamFlags flags);
void                g_value_set_object                  (GValue *value,
                                                         gpointer v_object);
void                g_value_take_object                 (GValue *value,
                                                         gpointer v_object);
void                g_value_set_object_take_ownership   (GValue *value,
                                                         gpointer v_object);
gpointer            g_value_get_object                  (const GValue *value);
gpointer            g_value_dup_object                  (const GValue *value);

#define             G_IS_PARAM_SPEC_UNICHAR             (pspec)
#define             G_PARAM_SPEC_UNICHAR                (pspec)
#define             G_TYPE_PARAM_UNICHAR
                    GParamSpecUnichar;
GParamSpec*         g_param_spec_unichar                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gunichar default_value,
                                                         GParamFlags flags);

#define             G_IS_PARAM_SPEC_VALUE_ARRAY         (pspec)
#define             G_PARAM_SPEC_VALUE_ARRAY            (pspec)
#define             G_TYPE_PARAM_VALUE_ARRAY
                    GParamSpecValueArray;
GParamSpec*         g_param_spec_value_array            (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamSpec *element_spec,
                                                         GParamFlags flags);

#define             G_IS_PARAM_SPEC_OVERRIDE            (pspec)
#define             G_PARAM_SPEC_OVERRIDE               (pspec)
#define             G_TYPE_PARAM_OVERRIDE
                    GParamSpecOverride;
GParamSpec*         g_param_spec_override               (const gchar *name,
                                                         GParamSpec *overridden);

#define             G_IS_PARAM_SPEC_GTYPE               (pspec)
#define             G_PARAM_SPEC_GTYPE                  (pspec)
#define             G_VALUE_HOLDS_GTYPE                 (value)
#define             G_TYPE_PARAM_GTYPE
                    GParamSpecGType;
GParamSpec*         g_param_spec_gtype                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType is_a_type,
                                                         GParamFlags flags);
GType               g_value_get_gtype                   (const GValue *value);
void                g_value_set_gtype                   (GValue *value,
                                                         GType v_gtype);

Description

GValue provides an abstract container structure which can be copied, transformed and compared while holding a value of any (derived) type, which is registered as a GType with a GTypeValueTable in its GTypeInfo structure. Parameter specifications for most value types can be created as GParamSpec derived instances, to implement e.g. GObject properties which operate on GValue containers.

Parameter names need to start with a letter (a-z or A-Z). Subsequent characters can be letters, numbers or a '-'. All other characters are replaced by a '-' during construction.

Details

G_IS_PARAM_SPEC_BOOLEAN()

#define G_IS_PARAM_SPEC_BOOLEAN(pspec)     (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOOLEAN))

Return whether the given GParamSpec is of type G_TYPE_PARAM_BOOLEAN.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_BOOLEAN()

#define G_PARAM_SPEC_BOOLEAN(pspec)        (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOOLEAN, GParamSpecBoolean))

Cast a GParamSpec instance into a GParamSpecBoolean.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_BOOLEAN()

#define G_VALUE_HOLDS_BOOLEAN(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOOLEAN))

Return whether the given GValue can hold values of type G_TYPE_BOOLEAN.

value : a valid GValue structure

G_TYPE_PARAM_BOOLEAN

#define	G_TYPE_PARAM_BOOLEAN		   (g_param_spec_types[2])

The GType of GParamSpecBoolean.

GParamSpecBoolean

typedef struct {
  GParamSpec    parent_instance;
  
  gboolean      default_value;
} GParamSpecBoolean;

A GParamSpec derived structure that contains the meta data for boolean properties.

GParamSpec `parent_instance`;	private GParamSpec portion
gboolean `default_value`;	default value for the property specified

g_param_spec_boolean ()

GParamSpec*         g_param_spec_boolean                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gboolean default_value,
                                                         GParamFlags flags);

Creates a new GParamSpecBoolean instance specifying a G_TYPE_BOOLEAN property.

See g_param_spec_internal() for details on property names.

`name` :	canonical name of the property specified
`nick` :	nick name for the property specified
`blurb` :	description of the property specified
`default_value` :	default value for the property specified
`flags` :	flags for the property specified
Returns :	a newly created parameter specification

g_value_set_boolean ()

void                g_value_set_boolean                 (GValue *value,
                                                         gboolean v_boolean);

Set the contents of a G_TYPE_BOOLEAN GValue to v_boolean.

`value` :	a valid GValue of type `G_TYPE_BOOLEAN`
`v_boolean` :	boolean value to be set

g_value_get_boolean ()

gboolean            g_value_get_boolean                 (const GValue *value);

Get the contents of a G_TYPE_BOOLEAN GValue.

`value` :	a valid GValue of type `G_TYPE_BOOLEAN`
Returns :	boolean contents of `value`

G_IS_PARAM_SPEC_CHAR()

#define G_IS_PARAM_SPEC_CHAR(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_CHAR))

Return whether the given GParamSpec is of type G_TYPE_PARAM_CHAR.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_CHAR()

#define G_PARAM_SPEC_CHAR(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_CHAR, GParamSpecChar))

Cast a GParamSpec instance into a GParamSpecChar.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_CHAR()

#define G_VALUE_HOLDS_CHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_CHAR))

Return whether the given GValue can hold values of type G_TYPE_CHAR.

value : a valid GValue structure

G_TYPE_PARAM_CHAR

#define	G_TYPE_PARAM_CHAR		   (g_param_spec_types[0])

The GType of GParamSpecChar.

GParamSpecChar

typedef struct {
  GParamSpec    parent_instance;
  
  gint8         minimum;
  gint8         maximum;
  gint8         default_value;
} GParamSpecChar;

A GParamSpec derived structure that contains the meta data for character properties.

GParamSpec `parent_instance`;	private GParamSpec portion
gint8 `minimum`;	minimum value for the property specified
gint8 `maximum`;	maximum value for the property specified
gint8 `default_value`;	default value for the property specified

g_param_spec_char ()

GParamSpec*         g_param_spec_char                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint8 minimum,
                                                         gint8 maximum,
                                                         gint8 default_value,
                                                         GParamFlags flags);

Creates a new GParamSpecChar instance specifying a G_TYPE_CHAR property.

`name` :	canonical name of the property specified
`nick` :	nick name for the property specified
`blurb` :	description of the property specified
`minimum` :	minimum value for the property specified
`maximum` :	maximum value for the property specified
`default_value` :	default value for the property specified
`flags` :	flags for the property specified
Returns :	a newly created parameter specification

g_value_set_char ()

void                g_value_set_char                    (GValue *value,
                                                         gchar v_char);

Set the contents of a G_TYPE_CHAR GValue to v_char.

`value` :	a valid GValue of type `G_TYPE_CHAR`
`v_char` :	character value to be set

g_value_get_char ()

gchar               g_value_get_char                    (const GValue *value);

Get the contents of a G_TYPE_CHAR GValue.

`value` :	a valid GValue of type `G_TYPE_CHAR`
Returns :	character contents of `value`

G_IS_PARAM_SPEC_UCHAR()

#define G_IS_PARAM_SPEC_UCHAR(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UCHAR))

Return whether the given GParamSpec is of type G_TYPE_PARAM_UCHAR.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_UCHAR()

#define G_PARAM_SPEC_UCHAR(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UCHAR, GParamSpecUChar))

Cast a GParamSpec instance into a GParamSpecUChar.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_UCHAR()

#define G_VALUE_HOLDS_UCHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UCHAR))

Return whether the given GValue can hold values of type G_TYPE_UCHAR.

value : a valid GValue structure

G_TYPE_PARAM_UCHAR

#define	G_TYPE_PARAM_UCHAR		   (g_param_spec_types[1])

The GType of GParamSpecUChar.

GParamSpecUChar

typedef struct {
  GParamSpec    parent_instance;
  
  guint8        minimum;
  guint8        maximum;
  guint8        default_value;
} GParamSpecUChar;

A GParamSpec derived structure that contains the meta data for unsigned character properties.

GParamSpec `parent_instance`;	private GParamSpec portion
guint8 `minimum`;	minimum value for the property specified
guint8 `maximum`;	maximum value for the property specified
guint8 `default_value`;	default value for the property specified

g_param_spec_uchar ()

GParamSpec*         g_param_spec_uchar                  (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint8 minimum,
                                                         guint8 maximum,
                                                         guint8 default_value,
                                                         GParamFlags flags);

Creates a new GParamSpecUChar instance specifying a G_TYPE_UCHAR property.

`name` :	canonical name of the property specified
`nick` :	nick name for the property specified
`blurb` :	description of the property specified
`minimum` :	minimum value for the property specified
`maximum` :	maximum value for the property specified
`default_value` :	default value for the property specified
`flags` :	flags for the property specified
Returns :	a newly created parameter specification

g_value_set_uchar ()

void                g_value_set_uchar                   (GValue *value,
                                                         guchar v_uchar);

Set the contents of a G_TYPE_UCHAR GValue to v_uchar.

`value` :	a valid GValue of type `G_TYPE_UCHAR`
`v_uchar` :	unsigned character value to be set

g_value_get_uchar ()

guchar              g_value_get_uchar                   (const GValue *value);

Get the contents of a G_TYPE_UCHAR GValue.

`value` :	a valid GValue of type `G_TYPE_UCHAR`
Returns :	unsigned character contents of `value`

G_IS_PARAM_SPEC_INT()

#define G_IS_PARAM_SPEC_INT(pspec)         (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT))

Return whether the given GParamSpec is of type G_TYPE_PARAM_INT.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_INT()

#define G_PARAM_SPEC_INT(pspec)            (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT, GParamSpecInt))

Cast a GParamSpec instance into a GParamSpecInt.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_INT()

#define G_VALUE_HOLDS_INT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT))

Return whether the given GValue can hold values of type G_TYPE_INT.

value : a valid GValue structure

G_TYPE_PARAM_INT

#define	G_TYPE_PARAM_INT		   (g_param_spec_types[3])

The GType of GParamSpecInt.

GParamSpecInt

typedef struct {
  GParamSpec    parent_instance;
  
  gint          minimum;
  gint          maximum;
  gint          default_value;
} GParamSpecInt;

A GParamSpec derived structure that contains the meta data for integer properties.

GParamSpec `parent_instance`;	private GParamSpec portion
gint `minimum`;	minimum value for the property specified
gint `maximum`;	maximum value for the property specified
gint `default_value`;	default value for the property specified

g_param_spec_int ()

GParamSpec*         g_param_spec_int                    (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint minimum,
                                                         gint maximum,
                                                         gint default_value,
                                                         GParamFlags flags);

Creates a new GParamSpecInt instance specifying a G_TYPE_INT property.

See g_param_spec_internal() for details on property names.

`name` :	canonical name of the property specified
`nick` :	nick name for the property specified
`blurb` :	description of the property specified
`minimum` :	minimum value for the property specified
`maximum` :	maximum value for the property specified
`default_value` :	default value for the property specified
`flags` :	flags for the property specified
Returns :	a newly created parameter specification

g_value_set_int ()

void                g_value_set_int                     (GValue *value,
                                                         gint v_int);

Set the contents of a G_TYPE_INT GValue to v_int.

`value` :	a valid GValue of type `G_TYPE_INT`
`v_int` :	integer value to be set

g_value_get_int ()

gint                g_value_get_int                     (const GValue *value);

Get the contents of a G_TYPE_INT GValue.

`value` :	a valid GValue of type `G_TYPE_INT`
Returns :	integer contents of `value`

G_IS_PARAM_SPEC_UINT()

#define G_IS_PARAM_SPEC_UINT(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT))

Return whether the given GParamSpec is of type G_TYPE_PARAM_UINT.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_UINT()

#define G_PARAM_SPEC_UINT(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT, GParamSpecUInt))

Cast a GParamSpec instance into a GParamSpecUInt.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_UINT()

#define G_VALUE_HOLDS_UINT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT))

Return whether the given GValue can hold values of type G_TYPE_UINT.

value : a valid GValue structure

G_TYPE_PARAM_UINT

#define	G_TYPE_PARAM_UINT		   (g_param_spec_types[4])

The GType of GParamSpecUInt.

GParamSpecUInt

typedef struct {
  GParamSpec    parent_instance;
  
  guint         minimum;
  guint         maximum;
  guint         default_value;
} GParamSpecUInt;

A GParamSpec derived structure that contains the meta data for unsigned integer properties.

GParamSpec `parent_instance`;	private GParamSpec portion
guint `minimum`;	minimum value for the property specified
guint `maximum`;	maximum value for the property specified
guint `default_value`;	default value for the property specified

g_param_spec_uint ()

GParamSpec*         g_param_spec_uint                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint minimum,
                                                         guint maximum,
                                                         guint default_value,
                                                         GParamFlags flags);

Creates a new GParamSpecUInt instance specifying a G_TYPE_UINT property.

See g_param_spec_internal() for details on property names.

`name` :	canonical name of the property specified
`nick` :	nick name for the property specified
`blurb` :	description of the property specified
`minimum` :	minimum value for the property specified
`maximum` :	maximum value for the property specified
`default_value` :	default value for the property specified
`flags` :	flags for the property specified
Returns :	a newly created parameter specification

g_value_set_uint ()

void                g_value_set_uint                    (GValue *value,
                                                         guint v_uint);

Set the contents of a G_TYPE_UINT GValue to v_uint.

`value` :	a valid GValue of type `G_TYPE_UINT`
`v_uint` :	unsigned integer value to be set

g_value_get_uint ()

guint               g_value_get_uint                    (const GValue *value);

Get the contents of a G_TYPE_UINT GValue.

`value` :	a valid GValue of type `G_TYPE_UINT`
Returns :	unsigned integer contents of `value`

G_IS_PARAM_SPEC_LONG()

#define G_IS_PARAM_SPEC_LONG(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_LONG))

Return whether the given GParamSpec is of type G_TYPE_PARAM_LONG.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_LONG()

#define G_PARAM_SPEC_LONG(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_LONG, GParamSpecLong))

Cast a GParamSpec instance into a GParamSpecLong.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_LONG()

#define G_VALUE_HOLDS_LONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_LONG))

Return whether the given GValue can hold values of type G_TYPE_LONG.

value : a valid GValue structure

G_TYPE_PARAM_LONG

#define	G_TYPE_PARAM_LONG		   (g_param_spec_types[5])

The GType of GParamSpecLong.

GParamSpecLong

typedef struct {
  GParamSpec    parent_instance;
  
  glong         minimum;
  glong         maximum;
  glong         default_value;
} GParamSpecLong;

A GParamSpec derived structure that contains the meta data for long integer properties.

GParamSpec `parent_instance`;	private GParamSpec portion
glong `minimum`;	minimum value for the property specified
glong `maximum`;	maximum value for the property specified
glong `default_value`;	default value for the property specified

g_param_spec_long ()

GParamSpec*         g_param_spec_long                   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         glong minimum,
                                                         glong maximum,
                                                         glong default_value,
                                                         GParamFlags flags);

Creates a new GParamSpecLong instance specifying a G_TYPE_LONG property.

See g_param_spec_internal() for details on property names.

`name` :	canonical name of the property specified
`nick` :	nick name for the property specified
`blurb` :	description of the property specified
`minimum` :	minimum value for the property specified
`maximum` :	maximum value for the property specified
`default_value` :	default value for the property specified
`flags` :	flags for the property specified
Returns :	a newly created parameter specification

g_value_set_long ()

void                g_value_set_long                    (GValue *value,
                                                         glong v_long);

Set the contents of a G_TYPE_LONG GValue to v_long.

`value` :	a valid GValue of type `G_TYPE_LONG`
`v_long` :	long integer value to be set

g_value_get_long ()

glong               g_value_get_long                    (const GValue *value);

Get the contents of a G_TYPE_LONG GValue.

`value` :	a valid GValue of type `G_TYPE_LONG`
Returns :	long integer contents of `value`

G_IS_PARAM_SPEC_ULONG()

#define G_IS_PARAM_SPEC_ULONG(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ULONG))

Return whether the given GParamSpec is of type G_TYPE_PARAM_ULONG.

pspec : a valid GParamSpec instance

G_PARAM_SPEC_ULONG()

#define G_PARAM_SPEC_ULONG(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ULONG, GParamSpecULong))

Cast a GParamSpec instance into a GParamSpecULong.

pspec : a valid GParamSpec instance

G_VALUE_HOLDS_ULONG()

#define G_VALUE_HOLDS_ULONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ULONG))

Return whether the given GValue can hold values of type G_TYPE_ULONG.

value : a valid GValue structure

G_TYPE_PARAM_ULONG

#define	G_TYPE_PARAM_ULONG		   (g_param_spec_types[6])

The GType of GParamSpecULong.

GParamSpecULong

typedef struct {
  GParamSpec    parent_instance;
  
  gulong        minimum;
  gulong        maximum;
  gulong        default_value;
} GParamSpecULong;

A GParamSpec derived structure that contains the meta data for unsigned long integer properties.

GParamSpec `parent_instance`;	private GParamSpec portion
gulong `minimum`;	minimum value for the property specified
gulong `maximum`;	maximum value for the property specified
gulong `default_value`;	default value for the

			GObject Reference Manual
Top \| Description

GNOME Documentation Library