<refentry id="gobject-Standard-Parameter-and-Value-Types">
<refmeta>
<refentrytitle>Parameters and Values</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>GOBJECT Library</refmiscinfo>
</refmeta>

<refnamediv>
<refname>Parameters and Values</refname><refpurpose>Standard Parameter and Value Types.</refpurpose>
</refnamediv>

<refsynopsisdiv><title>Synopsis</title>
<synopsis>

#include &lt;gobject.h&gt;



#define     <link linkend="G-IS-PARAM-SPEC-BOOLEAN-CAPS">G_IS_PARAM_SPEC_BOOLEAN</link>         (pspec)
#define     <link linkend="G-PARAM-SPEC-BOOLEAN-CAPS">G_PARAM_SPEC_BOOLEAN</link>            (pspec)
#define     <link linkend="G-VALUE-HOLDS-BOOLEAN-CAPS">G_VALUE_HOLDS_BOOLEAN</link>           (value)
#define     <link linkend="G-TYPE-PARAM-BOOLEAN-CAPS">G_TYPE_PARAM_BOOLEAN</link>
struct      <link linkend="GParamSpecBoolean">GParamSpecBoolean</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-boolean">g_param_spec_boolean</link>            (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gboolean">gboolean</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-boolean">g_value_set_boolean</link>             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gboolean">gboolean</link> v_boolean);
<link linkend="gboolean">gboolean</link>    <link linkend="g-value-get-boolean">g_value_get_boolean</link>             (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-CHAR-CAPS">G_IS_PARAM_SPEC_CHAR</link>            (pspec)
#define     <link linkend="G-PARAM-SPEC-CHAR-CAPS">G_PARAM_SPEC_CHAR</link>               (pspec)
#define     <link linkend="G-VALUE-HOLDS-CHAR-CAPS">G_VALUE_HOLDS_CHAR</link>              (value)
#define     <link linkend="G-TYPE-PARAM-CHAR-CAPS">G_TYPE_PARAM_CHAR</link>
struct      <link linkend="GParamSpecChar">GParamSpecChar</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-char">g_param_spec_char</link>               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gint8">gint8</link> minimum,
                                             <link linkend="gint8">gint8</link> maximum,
                                             <link linkend="gint8">gint8</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-char">g_value_set_char</link>                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> v_char);
<link linkend="gchar">gchar</link>       <link linkend="g-value-get-char">g_value_get_char</link>                (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-UCHAR-CAPS">G_IS_PARAM_SPEC_UCHAR</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-UCHAR-CAPS">G_PARAM_SPEC_UCHAR</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-UCHAR-CAPS">G_VALUE_HOLDS_UCHAR</link>             (value)
#define     <link linkend="G-TYPE-PARAM-UCHAR-CAPS">G_TYPE_PARAM_UCHAR</link>
struct      <link linkend="GParamSpecUChar">GParamSpecUChar</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-uchar">g_param_spec_uchar</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="guint8">guint8</link> minimum,
                                             <link linkend="guint8">guint8</link> maximum,
                                             <link linkend="guint8">guint8</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-uchar">g_value_set_uchar</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guchar">guchar</link> v_uchar);
<link linkend="guchar">guchar</link>      <link linkend="g-value-get-uchar">g_value_get_uchar</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-INT-CAPS">G_IS_PARAM_SPEC_INT</link>             (pspec)
#define     <link linkend="G-PARAM-SPEC-INT-CAPS">G_PARAM_SPEC_INT</link>                (pspec)
#define     <link linkend="G-VALUE-HOLDS-INT-CAPS">G_VALUE_HOLDS_INT</link>               (value)
#define     <link linkend="G-TYPE-PARAM-INT-CAPS">G_TYPE_PARAM_INT</link>
struct      <link linkend="GParamSpecInt">GParamSpecInt</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-int">g_param_spec_int</link>                (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gint">gint</link> minimum,
                                             <link linkend="gint">gint</link> maximum,
                                             <link linkend="gint">gint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-int">g_value_set_int</link>                 (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint">gint</link> v_int);
<link linkend="gint">gint</link>        <link linkend="g-value-get-int">g_value_get_int</link>                 (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-UINT-CAPS">G_IS_PARAM_SPEC_UINT</link>            (pspec)
#define     <link linkend="G-PARAM-SPEC-UINT-CAPS">G_PARAM_SPEC_UINT</link>               (pspec)
#define     <link linkend="G-VALUE-HOLDS-UINT-CAPS">G_VALUE_HOLDS_UINT</link>              (value)
#define     <link linkend="G-TYPE-PARAM-UINT-CAPS">G_TYPE_PARAM_UINT</link>
struct      <link linkend="GParamSpecUInt">GParamSpecUInt</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-uint">g_param_spec_uint</link>               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="guint">guint</link> minimum,
                                             <link linkend="guint">guint</link> maximum,
                                             <link linkend="guint">guint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-uint">g_value_set_uint</link>                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint">guint</link> v_uint);
<link linkend="guint">guint</link>       <link linkend="g-value-get-uint">g_value_get_uint</link>                (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-LONG-CAPS">G_IS_PARAM_SPEC_LONG</link>            (pspec)
#define     <link linkend="G-PARAM-SPEC-LONG-CAPS">G_PARAM_SPEC_LONG</link>               (pspec)
#define     <link linkend="G-VALUE-HOLDS-LONG-CAPS">G_VALUE_HOLDS_LONG</link>              (value)
#define     <link linkend="G-TYPE-PARAM-LONG-CAPS">G_TYPE_PARAM_LONG</link>
struct      <link linkend="GParamSpecLong">GParamSpecLong</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-long">g_param_spec_long</link>               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="glong">glong</link> minimum,
                                             <link linkend="glong">glong</link> maximum,
                                             <link linkend="glong">glong</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-long">g_value_set_long</link>                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="glong">glong</link> v_long);
<link linkend="glong">glong</link>       <link linkend="g-value-get-long">g_value_get_long</link>                (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-ULONG-CAPS">G_IS_PARAM_SPEC_ULONG</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-ULONG-CAPS">G_PARAM_SPEC_ULONG</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-ULONG-CAPS">G_VALUE_HOLDS_ULONG</link>             (value)
#define     <link linkend="G-TYPE-PARAM-ULONG-CAPS">G_TYPE_PARAM_ULONG</link>
struct      <link linkend="GParamSpecULong">GParamSpecULong</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-ulong">g_param_spec_ulong</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gulong">gulong</link> minimum,
                                             <link linkend="gulong">gulong</link> maximum,
                                             <link linkend="gulong">gulong</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-ulong">g_value_set_ulong</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gulong">gulong</link> v_ulong);
<link linkend="gulong">gulong</link>      <link linkend="g-value-get-ulong">g_value_get_ulong</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-INT64-CAPS">G_IS_PARAM_SPEC_INT64</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-INT64-CAPS">G_PARAM_SPEC_INT64</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-INT64-CAPS">G_VALUE_HOLDS_INT64</link>             (value)
#define     <link linkend="G-TYPE-PARAM-INT64-CAPS">G_TYPE_PARAM_INT64</link>
struct      <link linkend="GParamSpecInt64">GParamSpecInt64</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-int64">g_param_spec_int64</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gint64">gint64</link> minimum,
                                             <link linkend="gint64">gint64</link> maximum,
                                             <link linkend="gint64">gint64</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-int64">g_value_set_int64</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint64">gint64</link> v_int64);
<link linkend="gint64">gint64</link>      <link linkend="g-value-get-int64">g_value_get_int64</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-UINT64-CAPS">G_IS_PARAM_SPEC_UINT64</link>          (pspec)
#define     <link linkend="G-PARAM-SPEC-UINT64-CAPS">G_PARAM_SPEC_UINT64</link>             (pspec)
#define     <link linkend="G-VALUE-HOLDS-UINT64-CAPS">G_VALUE_HOLDS_UINT64</link>            (value)
#define     <link linkend="G-TYPE-PARAM-UINT64-CAPS">G_TYPE_PARAM_UINT64</link>
struct      <link linkend="GParamSpecUInt64">GParamSpecUInt64</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-uint64">g_param_spec_uint64</link>             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="guint64">guint64</link> minimum,
                                             <link linkend="guint64">guint64</link> maximum,
                                             <link linkend="guint64">guint64</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-uint64">g_value_set_uint64</link>              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint64">guint64</link> v_uint64);
<link linkend="guint64">guint64</link>     <link linkend="g-value-get-uint64">g_value_get_uint64</link>              (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-FLOAT-CAPS">G_IS_PARAM_SPEC_FLOAT</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-FLOAT-CAPS">G_PARAM_SPEC_FLOAT</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-FLOAT-CAPS">G_VALUE_HOLDS_FLOAT</link>             (value)
#define     <link linkend="G-TYPE-PARAM-FLOAT-CAPS">G_TYPE_PARAM_FLOAT</link>
struct      <link linkend="GParamSpecFloat">GParamSpecFloat</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-float">g_param_spec_float</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gfloat">gfloat</link> minimum,
                                             <link linkend="gfloat">gfloat</link> maximum,
                                             <link linkend="gfloat">gfloat</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-float">g_value_set_float</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gfloat">gfloat</link> v_float);
<link linkend="gfloat">gfloat</link>      <link linkend="g-value-get-float">g_value_get_float</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-DOUBLE-CAPS">G_IS_PARAM_SPEC_DOUBLE</link>          (pspec)
#define     <link linkend="G-PARAM-SPEC-DOUBLE-CAPS">G_PARAM_SPEC_DOUBLE</link>             (pspec)
#define     <link linkend="G-VALUE-HOLDS-DOUBLE-CAPS">G_VALUE_HOLDS_DOUBLE</link>            (value)
#define     <link linkend="G-TYPE-PARAM-DOUBLE-CAPS">G_TYPE_PARAM_DOUBLE</link>
struct      <link linkend="GParamSpecDouble">GParamSpecDouble</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-double">g_param_spec_double</link>             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gdouble">gdouble</link> minimum,
                                             <link linkend="gdouble">gdouble</link> maximum,
                                             <link linkend="gdouble">gdouble</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-double">g_value_set_double</link>              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gdouble">gdouble</link> v_double);
<link linkend="gdouble">gdouble</link>     <link linkend="g-value-get-double">g_value_get_double</link>              (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-ENUM-CAPS">G_IS_PARAM_SPEC_ENUM</link>            (pspec)
#define     <link linkend="G-PARAM-SPEC-ENUM-CAPS">G_PARAM_SPEC_ENUM</link>               (pspec)
#define     <link linkend="G-VALUE-HOLDS-ENUM-CAPS">G_VALUE_HOLDS_ENUM</link>              (value)
#define     <link linkend="G-TYPE-PARAM-ENUM-CAPS">G_TYPE_PARAM_ENUM</link>
struct      <link linkend="GParamSpecEnum">GParamSpecEnum</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-enum">g_param_spec_enum</link>               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> enum_type,
                                             <link linkend="gint">gint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-enum">g_value_set_enum</link>                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint">gint</link> v_enum);
<link linkend="gint">gint</link>        <link linkend="g-value-get-enum">g_value_get_enum</link>                (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-FLAGS-CAPS">G_IS_PARAM_SPEC_FLAGS</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-FLAGS-CAPS">G_PARAM_SPEC_FLAGS</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-FLAGS-CAPS">G_VALUE_HOLDS_FLAGS</link>             (value)
#define     <link linkend="G-TYPE-PARAM-FLAGS-CAPS">G_TYPE_PARAM_FLAGS</link>
struct      <link linkend="GParamSpecFlags">GParamSpecFlags</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-flags">g_param_spec_flags</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> flags_type,
                                             <link linkend="guint">guint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-flags">g_value_set_flags</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint">guint</link> v_flags);
<link linkend="guint">guint</link>       <link linkend="g-value-get-flags">g_value_get_flags</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-STRING-CAPS">G_IS_PARAM_SPEC_STRING</link>          (pspec)
#define     <link linkend="G-PARAM-SPEC-STRING-CAPS">G_PARAM_SPEC_STRING</link>             (pspec)
#define     <link linkend="G-VALUE-HOLDS-STRING-CAPS">G_VALUE_HOLDS_STRING</link>            (value)
#define     <link linkend="G-TYPE-PARAM-STRING-CAPS">G_TYPE_PARAM_STRING</link>
struct      <link linkend="GParamSpecString">GParamSpecString</link>;
typedef     <link linkend="gchararray">gchararray</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-string">g_param_spec_string</link>             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             const <link linkend="gchar">gchar</link> *default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-string">g_value_set_string</link>              (<link linkend="GValue">GValue</link> *value,
                                             const <link linkend="gchar">gchar</link> *v_string);
void        <link linkend="g-value-set-static-string">g_value_set_static_string</link>       (<link linkend="GValue">GValue</link> *value,
                                             const <link linkend="gchar">gchar</link> *v_string);
void        <link linkend="g-value-set-string-take-ownership">g_value_set_string_take_ownership</link>
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> *v_string);
G_CONST_RETURN <link linkend="gchar">gchar</link>* <link linkend="g-value-get-string">g_value_get_string</link>    (const <link linkend="GValue">GValue</link> *value);
<link linkend="gchar">gchar</link>*      <link linkend="g-value-dup-string">g_value_dup_string</link>              (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-PARAM-CAPS">G_IS_PARAM_SPEC_PARAM</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-PARAM-CAPS">G_PARAM_SPEC_PARAM</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-PARAM-CAPS">G_VALUE_HOLDS_PARAM</link>             (value)
#define     <link linkend="G-TYPE-PARAM-PARAM-CAPS">G_TYPE_PARAM_PARAM</link>
struct      <link linkend="GParamSpecParam">GParamSpecParam</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-param">g_param_spec_param</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> param_type,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-param">g_value_set_param</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);
void        <link linkend="g-value-set-param-take-ownership">g_value_set_param_take_ownership</link>
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-value-get-param">g_value_get_param</link>               (const <link linkend="GValue">GValue</link> *value);
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-value-dup-param">g_value_dup_param</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-BOXED-CAPS">G_IS_PARAM_SPEC_BOXED</link>           (pspec)
#define     <link linkend="G-PARAM-SPEC-BOXED-CAPS">G_PARAM_SPEC_BOXED</link>              (pspec)
#define     <link linkend="G-VALUE-HOLDS-BOXED-CAPS">G_VALUE_HOLDS_BOXED</link>             (value)
#define     <link linkend="G-TYPE-PARAM-BOXED-CAPS">G_TYPE_PARAM_BOXED</link>
struct      <link linkend="GParamSpecBoxed">GParamSpecBoxed</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-boxed">g_param_spec_boxed</link>              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> boxed_type,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-boxed">g_value_set_boxed</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);
void        <link linkend="g-value-set-static-boxed">g_value_set_static_boxed</link>        (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);
void        <link linkend="g-value-set-boxed-take-ownership">g_value_set_boxed_take_ownership</link>
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);
<link linkend="gpointer">gpointer</link>    <link linkend="g-value-get-boxed">g_value_get_boxed</link>               (const <link linkend="GValue">GValue</link> *value);
<link linkend="gpointer">gpointer</link>    <link linkend="g-value-dup-boxed">g_value_dup_boxed</link>               (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-POINTER-CAPS">G_IS_PARAM_SPEC_POINTER</link>         (pspec)
#define     <link linkend="G-PARAM-SPEC-POINTER-CAPS">G_PARAM_SPEC_POINTER</link>            (pspec)
#define     <link linkend="G-VALUE-HOLDS-POINTER-CAPS">G_VALUE_HOLDS_POINTER</link>           (value)
#define     <link linkend="G-TYPE-PARAM-POINTER-CAPS">G_TYPE_PARAM_POINTER</link>
struct      <link linkend="GParamSpecPointer">GParamSpecPointer</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-pointer">g_param_spec_pointer</link>            (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-pointer">g_value_set_pointer</link>             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_pointer);
<link linkend="gpointer">gpointer</link>    <link linkend="g-value-get-pointer">g_value_get_pointer</link>             (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-OBJECT-CAPS">G_IS_PARAM_SPEC_OBJECT</link>          (pspec)
#define     <link linkend="G-PARAM-SPEC-OBJECT-CAPS">G_PARAM_SPEC_OBJECT</link>             (pspec)
#define     <link linkend="G-VALUE-HOLDS-OBJECT-CAPS">G_VALUE_HOLDS_OBJECT</link>            (value)
#define     <link linkend="G-TYPE-PARAM-OBJECT-CAPS">G_TYPE_PARAM_OBJECT</link>
struct      <link linkend="GParamSpecObject">GParamSpecObject</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-object">g_param_spec_object</link>             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> object_type,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);
void        <link linkend="g-value-set-object">g_value_set_object</link>              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);
void        <link linkend="g-value-set-object-take-ownership">g_value_set_object_take_ownership</link>
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);
<link linkend="gpointer">gpointer</link>    <link linkend="g-value-get-object">g_value_get_object</link>              (const <link linkend="GValue">GValue</link> *value);
<link linkend="GObject">GObject</link>*    <link linkend="g-value-dup-object">g_value_dup_object</link>              (const <link linkend="GValue">GValue</link> *value);

#define     <link linkend="G-IS-PARAM-SPEC-UNICHAR-CAPS">G_IS_PARAM_SPEC_UNICHAR</link>         (pspec)
#define     <link linkend="G-PARAM-SPEC-UNICHAR-CAPS">G_PARAM_SPEC_UNICHAR</link>            (pspec)
#define     <link linkend="G-TYPE-PARAM-UNICHAR-CAPS">G_TYPE_PARAM_UNICHAR</link>
struct      <link linkend="GParamSpecUnichar">GParamSpecUnichar</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-unichar">g_param_spec_unichar</link>            (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gunichar">gunichar</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);

#define     <link linkend="G-IS-PARAM-SPEC-VALUE-ARRAY-CAPS">G_IS_PARAM_SPEC_VALUE_ARRAY</link>     (pspec)
#define     <link linkend="G-PARAM-SPEC-VALUE-ARRAY-CAPS">G_PARAM_SPEC_VALUE_ARRAY</link>        (pspec)
#define     <link linkend="G-TYPE-PARAM-VALUE-ARRAY-CAPS">G_TYPE_PARAM_VALUE_ARRAY</link>
struct      <link linkend="GParamSpecValueArray">GParamSpecValueArray</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-value-array">g_param_spec_value_array</link>        (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GParamSpec">GParamSpec</link> *element_spec,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);

</synopsis>
</refsynopsisdiv>





<refsect1>
<title>Description</title>
<para>
<link linkend="GValue">GValue</link> 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 <link linkend="GType">GType</link> with a <link linkend="GTypeValueTable">GTypeValueTable</link> in its <link linkend="GTypeInfo">GTypeInfo</link> structure.
Parameter specifications for most value types can be created as
<link linkend="GParamSpec">GParamSpec</link> derived instances, to implement e.g. <link linkend="GObject">GObject</link> properties which
operate on <link linkend="GValue">GValue</link> containers.
</para>
</refsect1>

<refsect1>
<title>Details</title>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-BOOLEAN-CAPS">G_IS_PARAM_SPEC_BOOLEAN()</title>
<programlisting>#define G_IS_PARAM_SPEC_BOOLEAN(pspec)     (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOOLEAN))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_BOOLEAN</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-BOOLEAN-CAPS">G_PARAM_SPEC_BOOLEAN()</title>
<programlisting>#define G_PARAM_SPEC_BOOLEAN(pspec)        (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOOLEAN, GParamSpecBoolean))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecBoolean">GParamSpecBoolean</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-BOOLEAN-CAPS">G_VALUE_HOLDS_BOOLEAN()</title>
<programlisting>#define G_VALUE_HOLDS_BOOLEAN(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOOLEAN))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_BOOLEAN</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-BOOLEAN-CAPS">G_TYPE_PARAM_BOOLEAN</title>
<programlisting>#define	G_TYPE_PARAM_BOOLEAN		   (g_param_spec_types[2])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecBoolean">struct GParamSpecBoolean</title>
<programlisting>struct GParamSpecBoolean
{
  GParamSpec    parent_instance;
  
  gboolean      default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for boolean properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gboolean">gboolean</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-boolean">g_param_spec_boolean ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_boolean            (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gboolean">gboolean</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecBoolean">GParamSpecBoolean</link> instance specifying a <literal>G_TYPE_BOOLEAN</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-boolean">g_value_set_boolean ()</title>
<programlisting>void        g_value_set_boolean             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gboolean">gboolean</link> v_boolean);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_BOOLEAN</literal> <link linkend="GValue">GValue</link> to <parameter>v_boolean</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>    a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_BOOLEAN</literal>
</entry></row>
<row><entry align="right"><parameter>v_boolean</parameter>&nbsp;:</entry>
<entry>boolean value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-boolean">g_value_get_boolean ()</title>
<programlisting><link linkend="gboolean">gboolean</link>    g_value_get_boolean             (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_BOOLEAN</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_BOOLEAN</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>boolean contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-CHAR-CAPS">G_IS_PARAM_SPEC_CHAR()</title>
<programlisting>#define G_IS_PARAM_SPEC_CHAR(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_CHAR))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_CHAR</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-CHAR-CAPS">G_PARAM_SPEC_CHAR()</title>
<programlisting>#define G_PARAM_SPEC_CHAR(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_CHAR, GParamSpecChar))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecChar">GParamSpecChar</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-CHAR-CAPS">G_VALUE_HOLDS_CHAR()</title>
<programlisting>#define G_VALUE_HOLDS_CHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_CHAR))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_CHAR</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-CHAR-CAPS">G_TYPE_PARAM_CHAR</title>
<programlisting>#define	G_TYPE_PARAM_CHAR		   (g_param_spec_types[0])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecChar">struct GParamSpecChar</title>
<programlisting>struct GParamSpecChar
{
  GParamSpec    parent_instance;
  
  gint8         minimum;
  gint8         maximum;
  gint8         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for character properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gint8">gint8</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gint8">gint8</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gint8">gint8</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-char">g_param_spec_char ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_char               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gint8">gint8</link> minimum,
                                             <link linkend="gint8">gint8</link> maximum,
                                             <link linkend="gint8">gint8</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecChar">GParamSpecChar</link> instance specifying a <literal>G_TYPE_CHAR</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>      minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>      maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-char">g_value_set_char ()</title>
<programlisting>void        g_value_set_char                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> v_char);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_CHAR</literal> <link linkend="GValue">GValue</link> to <parameter>v_char</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry> a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_CHAR</literal>
</entry></row>
<row><entry align="right"><parameter>v_char</parameter>&nbsp;:</entry>
<entry>character value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-char">g_value_get_char ()</title>
<programlisting><link linkend="gchar">gchar</link>       g_value_get_char                (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_CHAR</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_CHAR</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>character contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UCHAR-CAPS">G_IS_PARAM_SPEC_UCHAR()</title>
<programlisting>#define G_IS_PARAM_SPEC_UCHAR(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UCHAR))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_UCHAR</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UCHAR-CAPS">G_PARAM_SPEC_UCHAR()</title>
<programlisting>#define G_PARAM_SPEC_UCHAR(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UCHAR, GParamSpecUChar))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecUChar">GParamSpecUChar</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-UCHAR-CAPS">G_VALUE_HOLDS_UCHAR()</title>
<programlisting>#define G_VALUE_HOLDS_UCHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UCHAR))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_UCHAR</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UCHAR-CAPS">G_TYPE_PARAM_UCHAR</title>
<programlisting>#define	G_TYPE_PARAM_UCHAR		   (g_param_spec_types[1])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUChar">struct GParamSpecUChar</title>
<programlisting>struct GParamSpecUChar
{
  GParamSpec    parent_instance;
  
  guint8        minimum;
  guint8        maximum;
  guint8        default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for unsigned character properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="guint8">guint8</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="guint8">guint8</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="guint8">guint8</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-uchar">g_param_spec_uchar ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_uchar              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="guint8">guint8</link> minimum,
                                             <link linkend="guint8">guint8</link> maximum,
                                             <link linkend="guint8">guint8</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecUChar">GParamSpecUChar</link> instance specifying a <literal>G_TYPE_UCHAR</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>        minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>        maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-uchar">g_value_set_uchar ()</title>
<programlisting>void        g_value_set_uchar               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guchar">guchar</link> v_uchar);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_UCHAR</literal> <link linkend="GValue">GValue</link> to <parameter>v_uchar</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_UCHAR</literal>
</entry></row>
<row><entry align="right"><parameter>v_uchar</parameter>&nbsp;:</entry>
<entry>unsigned character value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-uchar">g_value_get_uchar ()</title>
<programlisting><link linkend="guchar">guchar</link>      g_value_get_uchar               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_UCHAR</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_UCHAR</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>unsigned character contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-INT-CAPS">G_IS_PARAM_SPEC_INT()</title>
<programlisting>#define G_IS_PARAM_SPEC_INT(pspec)         (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_INT</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-INT-CAPS">G_PARAM_SPEC_INT()</title>
<programlisting>#define G_PARAM_SPEC_INT(pspec)            (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT, GParamSpecInt))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecInt">GParamSpecInt</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-INT-CAPS">G_VALUE_HOLDS_INT()</title>
<programlisting>#define G_VALUE_HOLDS_INT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_INT</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-INT-CAPS">G_TYPE_PARAM_INT</title>
<programlisting>#define	G_TYPE_PARAM_INT		   (g_param_spec_types[3])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecInt">struct GParamSpecInt</title>
<programlisting>struct GParamSpecInt
{
  GParamSpec    parent_instance;
  
  gint          minimum;
  gint          maximum;
  gint          default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for integer properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gint">gint</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gint">gint</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gint">gint</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-int">g_param_spec_int ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_int                (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gint">gint</link> minimum,
                                             <link linkend="gint">gint</link> maximum,
                                             <link linkend="gint">gint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecInt">GParamSpecInt</link> instance specifying a <literal>G_TYPE_INT</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>      minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>      maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-int">g_value_set_int ()</title>
<programlisting>void        g_value_set_int                 (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint">gint</link> v_int);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_INT</literal> <link linkend="GValue">GValue</link> to <parameter>v_int</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_INT</literal>
</entry></row>
<row><entry align="right"><parameter>v_int</parameter>&nbsp;:</entry>
<entry>integer value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-int">g_value_get_int ()</title>
<programlisting><link linkend="gint">gint</link>        g_value_get_int                 (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_INT</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_INT</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>integer contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UINT-CAPS">G_IS_PARAM_SPEC_UINT()</title>
<programlisting>#define G_IS_PARAM_SPEC_UINT(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_UINT</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UINT-CAPS">G_PARAM_SPEC_UINT()</title>
<programlisting>#define G_PARAM_SPEC_UINT(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT, GParamSpecUInt))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecUInt">GParamSpecUInt</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-UINT-CAPS">G_VALUE_HOLDS_UINT()</title>
<programlisting>#define G_VALUE_HOLDS_UINT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_UINT</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UINT-CAPS">G_TYPE_PARAM_UINT</title>
<programlisting>#define	G_TYPE_PARAM_UINT		   (g_param_spec_types[4])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUInt">struct GParamSpecUInt</title>
<programlisting>struct GParamSpecUInt
{
  GParamSpec    parent_instance;
  
  guint         minimum;
  guint         maximum;
  guint         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for unsigned integer properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="guint">guint</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="guint">guint</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="guint">guint</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-uint">g_param_spec_uint ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_uint               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="guint">guint</link> minimum,
                                             <link linkend="guint">guint</link> maximum,
                                             <link linkend="guint">guint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecUInt">GParamSpecUInt</link> instance specifying a <literal>G_TYPE_UINT</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>        minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>        maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-uint">g_value_set_uint ()</title>
<programlisting>void        g_value_set_uint                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint">guint</link> v_uint);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_UINT</literal> <link linkend="GValue">GValue</link> to <parameter>v_uint</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry> a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_UINT</literal>
</entry></row>
<row><entry align="right"><parameter>v_uint</parameter>&nbsp;:</entry>
<entry>unsigned integer value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-uint">g_value_get_uint ()</title>
<programlisting><link linkend="guint">guint</link>       g_value_get_uint                (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_UINT</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_UINT</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>unsigned integer contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-LONG-CAPS">G_IS_PARAM_SPEC_LONG()</title>
<programlisting>#define G_IS_PARAM_SPEC_LONG(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_LONG))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_LONG</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-LONG-CAPS">G_PARAM_SPEC_LONG()</title>
<programlisting>#define G_PARAM_SPEC_LONG(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_LONG, GParamSpecLong))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecLong">GParamSpecLong</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-LONG-CAPS">G_VALUE_HOLDS_LONG()</title>
<programlisting>#define G_VALUE_HOLDS_LONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_LONG))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_LONG</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-LONG-CAPS">G_TYPE_PARAM_LONG</title>
<programlisting>#define	G_TYPE_PARAM_LONG		   (g_param_spec_types[5])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecLong">struct GParamSpecLong</title>
<programlisting>struct GParamSpecLong
{
  GParamSpec    parent_instance;
  
  glong         minimum;
  glong         maximum;
  glong         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for long integer properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="glong">glong</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="glong">glong</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="glong">glong</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-long">g_param_spec_long ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_long               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="glong">glong</link> minimum,
                                             <link linkend="glong">glong</link> maximum,
                                             <link linkend="glong">glong</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecLong">GParamSpecLong</link> instance specifying a <literal>G_TYPE_LONG</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>      minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>      maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-long">g_value_set_long ()</title>
<programlisting>void        g_value_set_long                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="glong">glong</link> v_long);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_LONG</literal> <link linkend="GValue">GValue</link> to <parameter>v_long</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry> a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_LONG</literal>
</entry></row>
<row><entry align="right"><parameter>v_long</parameter>&nbsp;:</entry>
<entry>long integer value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-long">g_value_get_long ()</title>
<programlisting><link linkend="glong">glong</link>       g_value_get_long                (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_LONG</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_LONG</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>long integer contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-ULONG-CAPS">G_IS_PARAM_SPEC_ULONG()</title>
<programlisting>#define G_IS_PARAM_SPEC_ULONG(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ULONG))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_ULONG</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-ULONG-CAPS">G_PARAM_SPEC_ULONG()</title>
<programlisting>#define G_PARAM_SPEC_ULONG(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ULONG, GParamSpecULong))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecULong">GParamSpecULong</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-ULONG-CAPS">G_VALUE_HOLDS_ULONG()</title>
<programlisting>#define G_VALUE_HOLDS_ULONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ULONG))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_ULONG</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-ULONG-CAPS">G_TYPE_PARAM_ULONG</title>
<programlisting>#define	G_TYPE_PARAM_ULONG		   (g_param_spec_types[6])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecULong">struct GParamSpecULong</title>
<programlisting>struct GParamSpecULong
{
  GParamSpec    parent_instance;
  
  gulong        minimum;
  gulong        maximum;
  gulong        default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for unsigned long integer properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gulong">gulong</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gulong">gulong</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gulong">gulong</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-ulong">g_param_spec_ulong ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_ulong              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gulong">gulong</link> minimum,
                                             <link linkend="gulong">gulong</link> maximum,
                                             <link linkend="gulong">gulong</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecULong">GParamSpecULong</link> instance specifying a <literal>G_TYPE_ULONG</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>        minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>        maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-ulong">g_value_set_ulong ()</title>
<programlisting>void        g_value_set_ulong               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gulong">gulong</link> v_ulong);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_ULONG</literal> <link linkend="GValue">GValue</link> to <parameter>v_ulong</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_ULONG</literal>
</entry></row>
<row><entry align="right"><parameter>v_ulong</parameter>&nbsp;:</entry>
<entry>unsigned long integer value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-ulong">g_value_get_ulong ()</title>
<programlisting><link linkend="gulong">gulong</link>      g_value_get_ulong               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_ULONG</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_ULONG</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>unsigned long integer contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-INT64-CAPS">G_IS_PARAM_SPEC_INT64()</title>
<programlisting>#define G_IS_PARAM_SPEC_INT64(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT64))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_INT64</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-INT64-CAPS">G_PARAM_SPEC_INT64()</title>
<programlisting>#define G_PARAM_SPEC_INT64(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT64, GParamSpecInt64))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecInt64">GParamSpecInt64</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-INT64-CAPS">G_VALUE_HOLDS_INT64()</title>
<programlisting>#define G_VALUE_HOLDS_INT64(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT64))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_INT64</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-INT64-CAPS">G_TYPE_PARAM_INT64</title>
<programlisting>#define	G_TYPE_PARAM_INT64		   (g_param_spec_types[7])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecInt64">struct GParamSpecInt64</title>
<programlisting>struct GParamSpecInt64
{
  GParamSpec    parent_instance;
  
  gint64        minimum;
  gint64        maximum;
  gint64        default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for 64bit integer properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gint64">gint64</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gint64">gint64</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gint64">gint64</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-int64">g_param_spec_int64 ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_int64              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gint64">gint64</link> minimum,
                                             <link linkend="gint64">gint64</link> maximum,
                                             <link linkend="gint64">gint64</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecInt64">GParamSpecInt64</link> instance specifying a <literal>G_TYPE_INT64</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>      minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>      maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-int64">g_value_set_int64 ()</title>
<programlisting>void        g_value_set_int64               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint64">gint64</link> v_int64);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_INT64</literal> <link linkend="GValue">GValue</link> to <parameter>v_int64</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry> a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_INT64</literal>
</entry></row>
<row><entry align="right"><parameter>v_int64</parameter>&nbsp;:</entry>
<entry>64bit integer value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-int64">g_value_get_int64 ()</title>
<programlisting><link linkend="gint64">gint64</link>      g_value_get_int64               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_INT64</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_INT64</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>64bit integer contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UINT64-CAPS">G_IS_PARAM_SPEC_UINT64()</title>
<programlisting>#define G_IS_PARAM_SPEC_UINT64(pspec)      (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT64))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_UINT64</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UINT64-CAPS">G_PARAM_SPEC_UINT64()</title>
<programlisting>#define G_PARAM_SPEC_UINT64(pspec)         (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT64, GParamSpecUInt64))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecUInt64">GParamSpecUInt64</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-UINT64-CAPS">G_VALUE_HOLDS_UINT64()</title>
<programlisting>#define G_VALUE_HOLDS_UINT64(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT64))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_UINT64</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UINT64-CAPS">G_TYPE_PARAM_UINT64</title>
<programlisting>#define	G_TYPE_PARAM_UINT64		   (g_param_spec_types[8])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUInt64">struct GParamSpecUInt64</title>
<programlisting>struct GParamSpecUInt64
{
  GParamSpec    parent_instance;
  
  guint64       minimum;
  guint64       maximum;
  guint64       default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for unsigned 64bit integer properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="guint64">guint64</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="guint64">guint64</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="guint64">guint64</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-uint64">g_param_spec_uint64 ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_uint64             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="guint64">guint64</link> minimum,
                                             <link linkend="guint64">guint64</link> maximum,
                                             <link linkend="guint64">guint64</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecUInt64">GParamSpecUInt64</link> instance specifying a <literal>G_TYPE_UINT64</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>        minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>        maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-uint64">g_value_set_uint64 ()</title>
<programlisting>void        g_value_set_uint64              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint64">guint64</link> v_uint64);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_UINT64</literal> <link linkend="GValue">GValue</link> to <parameter>v_uint64</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_UINT64</literal>
</entry></row>
<row><entry align="right"><parameter>v_uint64</parameter>&nbsp;:</entry>
<entry>unsigned 64bit integer value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-uint64">g_value_get_uint64 ()</title>
<programlisting><link linkend="guint64">guint64</link>     g_value_get_uint64              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_UINT64</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_UINT64</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>unsigned 64bit integer contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-FLOAT-CAPS">G_IS_PARAM_SPEC_FLOAT()</title>
<programlisting>#define G_IS_PARAM_SPEC_FLOAT(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLOAT))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_FLOAT</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-FLOAT-CAPS">G_PARAM_SPEC_FLOAT()</title>
<programlisting>#define G_PARAM_SPEC_FLOAT(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLOAT, GParamSpecFloat))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecFloat">GParamSpecFloat</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-FLOAT-CAPS">G_VALUE_HOLDS_FLOAT()</title>
<programlisting>#define G_VALUE_HOLDS_FLOAT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLOAT))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_FLOAT</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-FLOAT-CAPS">G_TYPE_PARAM_FLOAT</title>
<programlisting>#define	G_TYPE_PARAM_FLOAT		   (g_param_spec_types[12])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecFloat">struct GParamSpecFloat</title>
<programlisting>struct GParamSpecFloat
{
  GParamSpec    parent_instance;
  
  gfloat        minimum;
  gfloat        maximum;
  gfloat        default_value;
  gfloat        epsilon;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for float properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gfloat">gfloat</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gfloat">gfloat</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gfloat">gfloat</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gfloat">gfloat</link> <structfield>epsilon</structfield></entry>
<entry>

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-float">g_param_spec_float ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_float              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gfloat">gfloat</link> minimum,
                                             <link linkend="gfloat">gfloat</link> maximum,
                                             <link linkend="gfloat">gfloat</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecFloat">GParamSpecFloat</link> instance specifying a <literal>G_TYPE_FLOAT</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>      minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>      maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-float">g_value_set_float ()</title>
<programlisting>void        g_value_set_float               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gfloat">gfloat</link> v_float);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_FLOAT</literal> <link linkend="GValue">GValue</link> to <parameter>v_float</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>    a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_FLOAT</literal>
</entry></row>
<row><entry align="right"><parameter>v_float</parameter>&nbsp;:</entry>
<entry>float value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-float">g_value_get_float ()</title>
<programlisting><link linkend="gfloat">gfloat</link>      g_value_get_float               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_FLOAT</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_FLOAT</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>float contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-DOUBLE-CAPS">G_IS_PARAM_SPEC_DOUBLE()</title>
<programlisting>#define G_IS_PARAM_SPEC_DOUBLE(pspec)      (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_DOUBLE))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_DOUBLE</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-DOUBLE-CAPS">G_PARAM_SPEC_DOUBLE()</title>
<programlisting>#define G_PARAM_SPEC_DOUBLE(pspec)         (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_DOUBLE, GParamSpecDouble))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecDouble">GParamSpecDouble</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-DOUBLE-CAPS">G_VALUE_HOLDS_DOUBLE()</title>
<programlisting>#define G_VALUE_HOLDS_DOUBLE(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_DOUBLE))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values of type <literal>G_TYPE_DOUBLE</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-DOUBLE-CAPS">G_TYPE_PARAM_DOUBLE</title>
<programlisting>#define	G_TYPE_PARAM_DOUBLE		   (g_param_spec_types[13])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecDouble">struct GParamSpecDouble</title>
<programlisting>struct GParamSpecDouble
{
  GParamSpec    parent_instance;
  
  gdouble       minimum;
  gdouble       maximum;
  gdouble       default_value;
  gdouble       epsilon;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for double properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gdouble">gdouble</link> <structfield>minimum</structfield></entry>
<entry>        minimum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gdouble">gdouble</link> <structfield>maximum</structfield></entry>
<entry>        maximum value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gdouble">gdouble</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified
</entry>
</row>
<row>
<entry><link linkend="gdouble">gdouble</link> <structfield>epsilon</structfield></entry>
<entry>

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-double">g_param_spec_double ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_double             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gdouble">gdouble</link> minimum,
                                             <link linkend="gdouble">gdouble</link> maximum,
                                             <link linkend="gdouble">gdouble</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecDouble">GParamSpecDouble</link> instance specifying a <literal>G_TYPE_DOUBLE</literal> property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>minimum</parameter>&nbsp;:</entry>
<entry>      minimum value for the property specified
</entry></row>
<row><entry align="right"><parameter>maximum</parameter>&nbsp;:</entry>
<entry>      maximum value for the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-double">g_value_set_double ()</title>
<programlisting>void        g_value_set_double              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gdouble">gdouble</link> v_double);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_DOUBLE</literal> <link linkend="GValue">GValue</link> to <parameter>v_double</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>    a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_DOUBLE</literal>
</entry></row>
<row><entry align="right"><parameter>v_double</parameter>&nbsp;:</entry>
<entry>double value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-double">g_value_get_double ()</title>
<programlisting><link linkend="gdouble">gdouble</link>     g_value_get_double              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_DOUBLE</literal> <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of type <literal>G_TYPE_DOUBLE</literal>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>double contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-ENUM-CAPS">G_IS_PARAM_SPEC_ENUM()</title>
<programlisting>#define G_IS_PARAM_SPEC_ENUM(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ENUM))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-ENUM-CAPS">G_PARAM_SPEC_ENUM()</title>
<programlisting>#define G_PARAM_SPEC_ENUM(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ENUM, GParamSpecEnum))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-ENUM-CAPS">G_VALUE_HOLDS_ENUM()</title>
<programlisting>#define G_VALUE_HOLDS_ENUM(value)      (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ENUM))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-ENUM-CAPS">G_TYPE_PARAM_ENUM</title>
<programlisting>#define	G_TYPE_PARAM_ENUM		   (g_param_spec_types[10])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecEnum">struct GParamSpecEnum</title>
<programlisting>struct GParamSpecEnum
{
  GParamSpec    parent_instance;
  
  GEnumClass   *enum_class;
  gint          default_value;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-enum">g_param_spec_enum ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_enum               (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> enum_type,
                                             <link linkend="gint">gint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>enum_type</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-enum">g_value_set_enum ()</title>
<programlisting>void        g_value_set_enum                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint">gint</link> v_enum);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_enum</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-enum">g_value_get_enum ()</title>
<programlisting><link linkend="gint">gint</link>        g_value_get_enum                (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-FLAGS-CAPS">G_IS_PARAM_SPEC_FLAGS()</title>
<programlisting>#define G_IS_PARAM_SPEC_FLAGS(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLAGS))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-FLAGS-CAPS">G_PARAM_SPEC_FLAGS()</title>
<programlisting>#define G_PARAM_SPEC_FLAGS(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLAGS, GParamSpecFlags))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-FLAGS-CAPS">G_VALUE_HOLDS_FLAGS()</title>
<programlisting>#define G_VALUE_HOLDS_FLAGS(value)     (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLAGS))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-FLAGS-CAPS">G_TYPE_PARAM_FLAGS</title>
<programlisting>#define	G_TYPE_PARAM_FLAGS		   (g_param_spec_types[11])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecFlags">struct GParamSpecFlags</title>
<programlisting>struct GParamSpecFlags
{
  GParamSpec    parent_instance;
  
  GFlagsClass  *flags_class;
  guint         default_value;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-flags">g_param_spec_flags ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_flags              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> flags_type,
                                             <link linkend="guint">guint</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags_type</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-flags">g_value_set_flags ()</title>
<programlisting>void        g_value_set_flags               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint">guint</link> v_flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_flags</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-flags">g_value_get_flags ()</title>
<programlisting><link linkend="guint">guint</link>       g_value_get_flags               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-STRING-CAPS">G_IS_PARAM_SPEC_STRING()</title>
<programlisting>#define G_IS_PARAM_SPEC_STRING(pspec)      (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_STRING))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-STRING-CAPS">G_PARAM_SPEC_STRING()</title>
<programlisting>#define G_PARAM_SPEC_STRING(pspec)         (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_STRING, GParamSpecString))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-STRING-CAPS">G_VALUE_HOLDS_STRING()</title>
<programlisting>#define G_VALUE_HOLDS_STRING(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_STRING))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-STRING-CAPS">G_TYPE_PARAM_STRING</title>
<programlisting>#define	G_TYPE_PARAM_STRING		   (g_param_spec_types[14])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecString">struct GParamSpecString</title>
<programlisting>struct GParamSpecString
{
  GParamSpec    parent_instance;
  
  gchar        *default_value;
  gchar        *cset_first;
  gchar        *cset_nth;
  gchar         substitutor;
  guint         null_fold_if_empty : 1;
  guint         ensure_non_null : 1;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="gchararray">gchararray</title>
<programlisting>typedef gchar* gchararray;
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-string">g_param_spec_string ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_string             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             const <link linkend="gchar">gchar</link> *default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-string">g_value_set_string ()</title>
<programlisting>void        g_value_set_string              (<link linkend="GValue">GValue</link> *value,
                                             const <link linkend="gchar">gchar</link> *v_string);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_string</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-static-string">g_value_set_static_string ()</title>
<programlisting>void        g_value_set_static_string       (<link linkend="GValue">GValue</link> *value,
                                             const <link linkend="gchar">gchar</link> *v_string);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_string</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-string-take-ownership">g_value_set_string_take_ownership ()</title>
<programlisting>void        g_value_set_string_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> *v_string);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_string</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-string">g_value_get_string ()</title>
<programlisting>G_CONST_RETURN <link linkend="gchar">gchar</link>* g_value_get_string    (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-dup-string">g_value_dup_string ()</title>
<programlisting><link linkend="gchar">gchar</link>*      g_value_dup_string              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-PARAM-CAPS">G_IS_PARAM_SPEC_PARAM()</title>
<programlisting>#define G_IS_PARAM_SPEC_PARAM(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_PARAM))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-PARAM-CAPS">G_PARAM_SPEC_PARAM()</title>
<programlisting>#define G_PARAM_SPEC_PARAM(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_PARAM, GParamSpecParam))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-PARAM-CAPS">G_VALUE_HOLDS_PARAM()</title>
<programlisting>#define G_VALUE_HOLDS_PARAM(value)	(G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_PARAM))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-PARAM-CAPS">G_TYPE_PARAM_PARAM</title>
<programlisting>#define	G_TYPE_PARAM_PARAM		   (g_param_spec_types[15])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecParam">struct GParamSpecParam</title>
<programlisting>struct GParamSpecParam
{
  GParamSpec    parent_instance;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-param">g_param_spec_param ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_param              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> param_type,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>param_type</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-param">g_value_set_param ()</title>
<programlisting>void        g_value_set_param               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>param</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-param-take-ownership">g_value_set_param_take_ownership ()</title>
<programlisting>void        g_value_set_param_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>param</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-param">g_value_get_param ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_value_get_param               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-dup-param">g_value_dup_param ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_value_dup_param               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-BOXED-CAPS">G_IS_PARAM_SPEC_BOXED()</title>
<programlisting>#define G_IS_PARAM_SPEC_BOXED(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOXED))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_BOXED</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-BOXED-CAPS">G_PARAM_SPEC_BOXED()</title>
<programlisting>#define G_PARAM_SPEC_BOXED(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOXED, GParamSpecBoxed))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecBoxed">GParamSpecBoxed</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-BOXED-CAPS">G_VALUE_HOLDS_BOXED()</title>
<programlisting>#define G_VALUE_HOLDS_BOXED(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOXED))
</programlisting>
<para>
Return whether the given <link linkend="GValue">GValue</link> can hold values derived from type <literal>G_TYPE_BOXED</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GValue">GValue</link> structure


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-BOXED-CAPS">G_TYPE_PARAM_BOXED</title>
<programlisting>#define	G_TYPE_PARAM_BOXED		   (g_param_spec_types[16])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecBoxed">struct GParamSpecBoxed</title>
<programlisting>struct GParamSpecBoxed
{
  GParamSpec    parent_instance;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for boxed properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-boxed">g_param_spec_boxed ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_boxed              (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> boxed_type,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecBoxed">GParamSpecBoxed</link> instance specifying a <literal>G_TYPE_BOXED</literal> derived property.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>boxed_type</parameter>&nbsp;:</entry>
<entry>   <literal>G_TYPE_BOXED</literal> derived type of this property
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-boxed">g_value_set_boxed ()</title>
<programlisting>void        g_value_set_boxed               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_BOXED</literal> derived <link linkend="GValue">GValue</link> to <parameter>v_boxed</parameter>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of <literal>G_TYPE_BOXED</literal> derived type
</entry></row>
<row><entry align="right"><parameter>v_boxed</parameter>&nbsp;:</entry>
<entry>boxed value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-static-boxed">g_value_set_static_boxed ()</title>
<programlisting>void        g_value_set_static_boxed        (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_BOXED</literal> derived <link linkend="GValue">GValue</link> to <parameter>v_boxed</parameter>.
The boxed value is assumed to be static, and is thus not duplicated
when setting the <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of <literal>G_TYPE_BOXED</literal> derived type
</entry></row>
<row><entry align="right"><parameter>v_boxed</parameter>&nbsp;:</entry>
<entry>static boxed value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-boxed-take-ownership">g_value_set_boxed_take_ownership ()</title>
<programlisting>void        g_value_set_boxed_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);</programlisting>
<para>
This is an internal function introduced mainly for C marshallers.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of <literal>G_TYPE_BOXED</literal> derived type
</entry></row>
<row><entry align="right"><parameter>v_boxed</parameter>&nbsp;:</entry>
<entry>duplicated unowned boxed value to be set


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-boxed">g_value_get_boxed ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    g_value_get_boxed               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_BOXED</literal> derived <link linkend="GValue">GValue</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of <literal>G_TYPE_BOXED</literal> derived type
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>boxed contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-dup-boxed">g_value_dup_boxed ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    g_value_dup_boxed               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_BOXED</literal> derived <link linkend="GValue">GValue</link>.
Upon getting, the boxed value is duplicated and needs to be
later freed with <link linkend="g-boxed-free">g_boxed_free</link>(), e.g. like: g_boxed_free (G_VALUE_TYPE (<parameter>value</parameter>), return_value);
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>  a valid <link linkend="GValue">GValue</link> of <literal>G_TYPE_BOXED</literal> derived type
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>boxed contents of <parameter>value</parameter>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-POINTER-CAPS">G_IS_PARAM_SPEC_POINTER()</title>
<programlisting>#define G_IS_PARAM_SPEC_POINTER(pspec)     (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_POINTER))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-POINTER-CAPS">G_PARAM_SPEC_POINTER()</title>
<programlisting>#define G_PARAM_SPEC_POINTER(pspec)        (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_POINTER, GParamSpecPointer))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-POINTER-CAPS">G_VALUE_HOLDS_POINTER()</title>
<programlisting>#define G_VALUE_HOLDS_POINTER(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_POINTER))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-POINTER-CAPS">G_TYPE_PARAM_POINTER</title>
<programlisting>#define	G_TYPE_PARAM_POINTER		   (g_param_spec_types[17])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecPointer">struct GParamSpecPointer</title>
<programlisting>struct GParamSpecPointer
{
  GParamSpec    parent_instance;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-pointer">g_param_spec_pointer ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_pointer            (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-pointer">g_value_set_pointer ()</title>
<programlisting>void        g_value_set_pointer             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_pointer);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_pointer</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-pointer">g_value_get_pointer ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    g_value_get_pointer             (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-OBJECT-CAPS">G_IS_PARAM_SPEC_OBJECT()</title>
<programlisting>#define G_IS_PARAM_SPEC_OBJECT(pspec)      (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OBJECT))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-OBJECT-CAPS">G_PARAM_SPEC_OBJECT()</title>
<programlisting>#define G_PARAM_SPEC_OBJECT(pspec)         (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OBJECT, GParamSpecObject))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-OBJECT-CAPS">G_VALUE_HOLDS_OBJECT()</title>
<programlisting>#define G_VALUE_HOLDS_OBJECT(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_OBJECT))
</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-OBJECT-CAPS">G_TYPE_PARAM_OBJECT</title>
<programlisting>#define	G_TYPE_PARAM_OBJECT		   (g_param_spec_types[19])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecObject">struct GParamSpecObject</title>
<programlisting>struct GParamSpecObject
{
  GParamSpec    parent_instance;
};
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-object">g_param_spec_object ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_object             (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GType">GType</link> object_type,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>object_type</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-object">g_value_set_object ()</title>
<programlisting>void        g_value_set_object              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_object</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-set-object-take-ownership">g_value_set_object_take_ownership ()</title>
<programlisting>void        g_value_set_object_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><parameter>v_object</parameter>&nbsp;:</entry>
<entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-get-object">g_value_get_object ()</title>
<programlisting><link linkend="gpointer">gpointer</link>    g_value_get_object              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-value-dup-object">g_value_dup_object ()</title>
<programlisting><link linkend="GObject">GObject</link>*    g_value_dup_object              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>

</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>value</parameter>&nbsp;:</entry>
<entry>
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UNICHAR-CAPS">G_IS_PARAM_SPEC_UNICHAR()</title>
<programlisting>#define G_IS_PARAM_SPEC_UNICHAR(pspec)     (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UNICHAR))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_UNICHAR</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UNICHAR-CAPS">G_PARAM_SPEC_UNICHAR()</title>
<programlisting>#define G_PARAM_SPEC_UNICHAR(pspec)        (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UNICHAR, GParamSpecUnichar))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecUnichar">GParamSpecUnichar</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UNICHAR-CAPS">G_TYPE_PARAM_UNICHAR</title>
<programlisting>#define	G_TYPE_PARAM_UNICHAR		   (g_param_spec_types[9])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUnichar">struct GParamSpecUnichar</title>
<programlisting>struct GParamSpecUnichar
{
  GParamSpec    parent_instance;
  
  gunichar      default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for unichar (unsigned integer) properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry>private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="gunichar">gunichar</link> <structfield>default_value</structfield></entry>
<entry>  default value for the property specified

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-unichar">g_param_spec_unichar ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_unichar            (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="gunichar">gunichar</link> default_value,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecUnichar">GParamSpecUnichar</link> instance specifying a <literal>G_TYPE_UINT</literal> property.
<link linkend="GValue">GValue</link> structures for this property
can be accessed with <link linkend="g-value-set-uint">g_value_set_uint</link>() and <link linkend="g-value-get-uint">g_value_get_uint</link>().
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>default_value</parameter>&nbsp;:</entry>
<entry>default value for the property specified
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-VALUE-ARRAY-CAPS">G_IS_PARAM_SPEC_VALUE_ARRAY()</title>
<programlisting>#define G_IS_PARAM_SPEC_VALUE_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_VALUE_ARRAY))
</programlisting>
<para>
Return whether the given <link linkend="GParamSpec">GParamSpec</link> is of type <literal>G_TYPE_PARAM_VALUE_ARRAY</literal>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-VALUE-ARRAY-CAPS">G_PARAM_SPEC_VALUE_ARRAY()</title>
<programlisting>#define G_PARAM_SPEC_VALUE_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_VALUE_ARRAY, GParamSpecValueArray))
</programlisting>
<para>
Cast a <link linkend="GParamSpec">GParamSpec</link> instance into a <link linkend="GParamSpecValueArray">GParamSpecValueArray</link>.
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>pspec</parameter>&nbsp;:</entry>
<entry>a valid <link linkend="GParamSpec">GParamSpec</link> instance


</entry></row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-VALUE-ARRAY-CAPS">G_TYPE_PARAM_VALUE_ARRAY</title>
<programlisting>#define	G_TYPE_PARAM_VALUE_ARRAY	   (g_param_spec_types[18])
</programlisting>
<para>

</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecValueArray">struct GParamSpecValueArray</title>
<programlisting>struct GParamSpecValueArray
{
  GParamSpec    parent_instance;
  GParamSpec   *element_spec;
  guint		fixed_n_elements;
};
</programlisting>
<para>
A <link linkend="GParamSpec">GParamSpec</link> derived structure that contains the meta data for <link linkend="GValueArray">GValueArray</link> properties.
</para><informaltable pgwide="1" frame="none" role="struct">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></entry>
<entry> private <link linkend="GParamSpec">GParamSpec</link> portion
</entry>
</row>
<row>
<entry><link linkend="GParamSpec">GParamSpec</link> *<structfield>element_spec</structfield></entry>
<entry>    a <link linkend="GParamSpec">GParamSpec</link> describing the elements contained in arrays of this property, may be <literal>NULL</literal>
</entry>
</row>
<row>
<entry><link linkend="guint">guint</link> <structfield>fixed_n_elements</structfield></entry>
<entry>if greater than 0, arrays of this property will always have this many elements

</entry>
</row>
</tbody></tgroup></informaltable></refsect2>
<refsect2>
<title><anchor id="g-param-spec-value-array">g_param_spec_value_array ()</title>
<programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_value_array        (const <link linkend="gchar">gchar</link> *name,
                                             const <link linkend="gchar">gchar</link> *nick,
                                             const <link linkend="gchar">gchar</link> *blurb,
                                             <link linkend="GParamSpec">GParamSpec</link> *element_spec,
                                             <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Create a new <link linkend="GParamSpecValueArray">GParamSpecValueArray</link> instance specifying a <literal>G_TYPE_VALUE_ARRAY</literal> property.
<literal>G_TYPE_VALUE_ARRAY</literal> is a <literal>G_TYPE_BOXED</literal> type, as such, <link linkend="GValue">GValue</link> structures for this property
can be accessed with <link linkend="g-value-set-boxed">g_value_set_boxed</link>() and <link linkend="g-value-get-boxed">g_value_get_boxed</link>().
</para><informaltable pgwide="1" frame="none" role="params">
<tgroup cols="2">
<colspec colwidth="2*">
<colspec colwidth="8*">
<tbody>
<row><entry align="right"><parameter>name</parameter>&nbsp;:</entry>
<entry>         canonical name of the property specified
</entry></row>
<row><entry align="right"><parameter>nick</parameter>&nbsp;:</entry>
<entry>         nick name for the property specified
</entry></row>
<row><entry align="right"><parameter>blurb</parameter>&nbsp;:</entry>
<entry>        description of the property specified
</entry></row>
<row><entry align="right"><parameter>element_spec</parameter>&nbsp;:</entry>
<entry> a <link linkend="GParamSpec">GParamSpec</link> describing the elements contained in arrays of this property, may be <literal>NULL</literal>
</entry></row>
<row><entry align="right"><parameter>flags</parameter>&nbsp;:</entry>
<entry>        flags for the property specified
</entry></row>
<row><entry align="right"><emphasis>Returns</emphasis> :</entry><entry>      a newly created parameter specification


</entry></row>
</tbody></tgroup></informaltable></refsect2>

</refsect1>



<refsect1>
<title>See Also</title>
<para>
<link linkend="GParamSpec">GParamSpec</link>, <link linkend="GValue">GValue</link>, <link linkend="g-object-class-install-property">g_object_class_install_property</link>().
</para>
</refsect1>

</refentry>
