<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;glib-object.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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <link linkend="g-value-take-string">g_value_take_string</link>             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> *v_string);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <link linkend="g-value-set-param">g_value_set_param</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);
<link linkend="void">void</link>        <link linkend="g-value-take-param">g_value_take_param</link>              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <link linkend="g-value-set-boxed">g_value_set_boxed</link>               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <link linkend="g-value-take-boxed">g_value_take_boxed</link>              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <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);
<link linkend="void">void</link>        <link linkend="g-value-set-object">g_value_set_object</link>              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);
<link linkend="void">void</link>        <link linkend="g-value-take-object">g_value_take_object</link>             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);
<link linkend="void">void</link>        <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);

#define     <link linkend="G-IS-PARAM-SPEC-OVERRIDE-CAPS">G_IS_PARAM_SPEC_OVERRIDE</link>        (pspec)
#define     <link linkend="G-PARAM-SPEC-OVERRIDE-CAPS">G_PARAM_SPEC_OVERRIDE</link>           (pspec)
#define     <link linkend="G-TYPE-PARAM-OVERRIDE-CAPS">G_TYPE_PARAM_OVERRIDE</link>
struct      <link linkend="GParamSpecOverride">GParamSpecOverride</link>;
<link linkend="GParamSpec">GParamSpec</link>* <link linkend="g-param-spec-override">g_param_spec_override</link>           (const <link linkend="gchar">gchar</link> *name,
                                             <link linkend="GParamSpec">GParamSpec</link> *overridden);

</synopsis>
</refsynopsisdiv>









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

<refsect1>
<title>Details</title>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-BOOLEAN-CAPS"/>G_IS_PARAM_SPEC_BOOLEAN()</title>
<indexterm><primary>G_IS_PARAM_SPEC_BOOLEAN</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_BOOLEAN</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-BOOLEAN-CAPS"/>G_PARAM_SPEC_BOOLEAN()</title>
<indexterm><primary>G_PARAM_SPEC_BOOLEAN</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecBoolean"><type>GParamSpecBoolean</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-BOOLEAN-CAPS"/>G_VALUE_HOLDS_BOOLEAN()</title>
<indexterm><primary>G_VALUE_HOLDS_BOOLEAN</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_BOOLEAN</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-BOOLEAN-CAPS"/>G_TYPE_PARAM_BOOLEAN</title>
<indexterm><primary>G_TYPE_PARAM_BOOLEAN</primary></indexterm><programlisting>#define	G_TYPE_PARAM_BOOLEAN		   (g_param_spec_types[2])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecBoolean"><type>GParamSpecBoolean</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecBoolean"/>struct GParamSpecBoolean</title>
<indexterm><primary>GParamSpecBoolean</primary></indexterm><programlisting>struct GParamSpecBoolean {

  GParamSpec    parent_instance;
  
  gboolean      default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for boolean properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gboolean">gboolean</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-boolean"/>g_param_spec_boolean ()</title>
<indexterm><primary>g_param_spec_boolean</primary></indexterm><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>
Creates a new <link linkend="GParamSpecBoolean"><type>GParamSpecBoolean</type></link> instance specifying a <literal>G_TYPE_BOOLEAN</literal> 
property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-boolean"/>g_value_set_boolean ()</title>
<indexterm><primary>g_value_set_boolean</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_boolean</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>    a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_BOOLEAN</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boolean</parameter>&nbsp;:</term>
<listitem><simpara>boolean value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-boolean"/>g_value_get_boolean ()</title>
<indexterm><primary>g_value_get_boolean</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_BOOLEAN</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>boolean contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-CHAR-CAPS"/>G_IS_PARAM_SPEC_CHAR()</title>
<indexterm><primary>G_IS_PARAM_SPEC_CHAR</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_CHAR</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-CHAR-CAPS"/>G_PARAM_SPEC_CHAR()</title>
<indexterm><primary>G_PARAM_SPEC_CHAR</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecChar"><type>GParamSpecChar</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-CHAR-CAPS"/>G_VALUE_HOLDS_CHAR()</title>
<indexterm><primary>G_VALUE_HOLDS_CHAR</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_CHAR</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-CHAR-CAPS"/>G_TYPE_PARAM_CHAR</title>
<indexterm><primary>G_TYPE_PARAM_CHAR</primary></indexterm><programlisting>#define	G_TYPE_PARAM_CHAR		   (g_param_spec_types[0])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecChar"><type>GParamSpecChar</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecChar"/>struct GParamSpecChar</title>
<indexterm><primary>GParamSpecChar</primary></indexterm><programlisting>struct GParamSpecChar {

  GParamSpec    parent_instance;
  
  gint8         minimum;
  gint8         maximum;
  gint8         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for character properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint8">gint8</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint8">gint8</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint8">gint8</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-char"/>g_param_spec_char ()</title>
<indexterm><primary>g_param_spec_char</primary></indexterm><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>
Creates a new <link linkend="GParamSpecChar"><type>GParamSpecChar</type></link> instance specifying a <literal>G_TYPE_CHAR</literal> property.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-char"/>g_value_set_char ()</title>
<indexterm><primary>g_value_set_char</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_char</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_CHAR</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_char</parameter>&nbsp;:</term>
<listitem><simpara>character value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-char"/>g_value_get_char ()</title>
<indexterm><primary>g_value_get_char</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_CHAR</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>character contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UCHAR-CAPS"/>G_IS_PARAM_SPEC_UCHAR()</title>
<indexterm><primary>G_IS_PARAM_SPEC_UCHAR</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_UCHAR</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UCHAR-CAPS"/>G_PARAM_SPEC_UCHAR()</title>
<indexterm><primary>G_PARAM_SPEC_UCHAR</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecUChar"><type>GParamSpecUChar</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-UCHAR-CAPS"/>G_VALUE_HOLDS_UCHAR()</title>
<indexterm><primary>G_VALUE_HOLDS_UCHAR</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_UCHAR</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UCHAR-CAPS"/>G_TYPE_PARAM_UCHAR</title>
<indexterm><primary>G_TYPE_PARAM_UCHAR</primary></indexterm><programlisting>#define	G_TYPE_PARAM_UCHAR		   (g_param_spec_types[1])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecUChar"><type>GParamSpecUChar</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUChar"/>struct GParamSpecUChar</title>
<indexterm><primary>GParamSpecUChar</primary></indexterm><programlisting>struct GParamSpecUChar {

  GParamSpec    parent_instance;
  
  guint8        minimum;
  guint8        maximum;
  guint8        default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned character properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint8">guint8</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint8">guint8</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint8">guint8</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-uchar"/>g_param_spec_uchar ()</title>
<indexterm><primary>g_param_spec_uchar</primary></indexterm><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>
Creates a new <link linkend="GParamSpecUChar"><type>GParamSpecUChar</type></link> instance specifying a <literal>G_TYPE_UCHAR</literal> property.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-uchar"/>g_value_set_uchar ()</title>
<indexterm><primary>g_value_set_uchar</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_uchar</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_UCHAR</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_uchar</parameter>&nbsp;:</term>
<listitem><simpara>unsigned character value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-uchar"/>g_value_get_uchar ()</title>
<indexterm><primary>g_value_get_uchar</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_UCHAR</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>unsigned character contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-INT-CAPS"/>G_IS_PARAM_SPEC_INT()</title>
<indexterm><primary>G_IS_PARAM_SPEC_INT</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_INT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-INT-CAPS"/>G_PARAM_SPEC_INT()</title>
<indexterm><primary>G_PARAM_SPEC_INT</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecInt"><type>GParamSpecInt</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-INT-CAPS"/>G_VALUE_HOLDS_INT()</title>
<indexterm><primary>G_VALUE_HOLDS_INT</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_INT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-INT-CAPS"/>G_TYPE_PARAM_INT</title>
<indexterm><primary>G_TYPE_PARAM_INT</primary></indexterm><programlisting>#define	G_TYPE_PARAM_INT		   (g_param_spec_types[3])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecInt"><type>GParamSpecInt</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecInt"/>struct GParamSpecInt</title>
<indexterm><primary>GParamSpecInt</primary></indexterm><programlisting>struct GParamSpecInt {

  GParamSpec    parent_instance;
  
  gint          minimum;
  gint          maximum;
  gint          default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for integer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint">gint</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint">gint</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint">gint</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-int"/>g_param_spec_int ()</title>
<indexterm><primary>g_param_spec_int</primary></indexterm><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>
Creates a new <link linkend="GParamSpecInt"><type>GParamSpecInt</type></link> instance specifying a <literal>G_TYPE_INT</literal> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-int"/>g_value_set_int ()</title>
<indexterm><primary>g_value_set_int</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_int</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_INT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_int</parameter>&nbsp;:</term>
<listitem><simpara>integer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-int"/>g_value_get_int ()</title>
<indexterm><primary>g_value_get_int</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_INT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>integer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UINT-CAPS"/>G_IS_PARAM_SPEC_UINT()</title>
<indexterm><primary>G_IS_PARAM_SPEC_UINT</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_UINT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UINT-CAPS"/>G_PARAM_SPEC_UINT()</title>
<indexterm><primary>G_PARAM_SPEC_UINT</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecUInt"><type>GParamSpecUInt</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-UINT-CAPS"/>G_VALUE_HOLDS_UINT()</title>
<indexterm><primary>G_VALUE_HOLDS_UINT</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_UINT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UINT-CAPS"/>G_TYPE_PARAM_UINT</title>
<indexterm><primary>G_TYPE_PARAM_UINT</primary></indexterm><programlisting>#define	G_TYPE_PARAM_UINT		   (g_param_spec_types[4])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecUInt"><type>GParamSpecUInt</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUInt"/>struct GParamSpecUInt</title>
<indexterm><primary>GParamSpecUInt</primary></indexterm><programlisting>struct GParamSpecUInt {

  GParamSpec    parent_instance;
  
  guint         minimum;
  guint         maximum;
  guint         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned integer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-uint"/>g_param_spec_uint ()</title>
<indexterm><primary>g_param_spec_uint</primary></indexterm><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>
Creates a new <link linkend="GParamSpecUInt"><type>GParamSpecUInt</type></link> instance specifying a <literal>G_TYPE_UINT</literal> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-uint"/>g_value_set_uint ()</title>
<indexterm><primary>g_value_set_uint</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_uint</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_UINT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_uint</parameter>&nbsp;:</term>
<listitem><simpara>unsigned integer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-uint"/>g_value_get_uint ()</title>
<indexterm><primary>g_value_get_uint</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_UINT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>unsigned integer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-LONG-CAPS"/>G_IS_PARAM_SPEC_LONG()</title>
<indexterm><primary>G_IS_PARAM_SPEC_LONG</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_LONG</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-LONG-CAPS"/>G_PARAM_SPEC_LONG()</title>
<indexterm><primary>G_PARAM_SPEC_LONG</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecLong"><type>GParamSpecLong</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-LONG-CAPS"/>G_VALUE_HOLDS_LONG()</title>
<indexterm><primary>G_VALUE_HOLDS_LONG</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_LONG</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-LONG-CAPS"/>G_TYPE_PARAM_LONG</title>
<indexterm><primary>G_TYPE_PARAM_LONG</primary></indexterm><programlisting>#define	G_TYPE_PARAM_LONG		   (g_param_spec_types[5])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecLong"><type>GParamSpecLong</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecLong"/>struct GParamSpecLong</title>
<indexterm><primary>GParamSpecLong</primary></indexterm><programlisting>struct GParamSpecLong {

  GParamSpec    parent_instance;
  
  glong         minimum;
  glong         maximum;
  glong         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for long integer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="glong">glong</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="glong">glong</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="glong">glong</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-long"/>g_param_spec_long ()</title>
<indexterm><primary>g_param_spec_long</primary></indexterm><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>
Creates a new <link linkend="GParamSpecLong"><type>GParamSpecLong</type></link> instance specifying a <literal>G_TYPE_LONG</literal> property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-long"/>g_value_set_long ()</title>
<indexterm><primary>g_value_set_long</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_long</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_LONG</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_long</parameter>&nbsp;:</term>
<listitem><simpara>long integer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-long"/>g_value_get_long ()</title>
<indexterm><primary>g_value_get_long</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_LONG</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>long integer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-ULONG-CAPS"/>G_IS_PARAM_SPEC_ULONG()</title>
<indexterm><primary>G_IS_PARAM_SPEC_ULONG</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_ULONG</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-ULONG-CAPS"/>G_PARAM_SPEC_ULONG()</title>
<indexterm><primary>G_PARAM_SPEC_ULONG</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecULong"><type>GParamSpecULong</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-ULONG-CAPS"/>G_VALUE_HOLDS_ULONG()</title>
<indexterm><primary>G_VALUE_HOLDS_ULONG</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_ULONG</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-ULONG-CAPS"/>G_TYPE_PARAM_ULONG</title>
<indexterm><primary>G_TYPE_PARAM_ULONG</primary></indexterm><programlisting>#define	G_TYPE_PARAM_ULONG		   (g_param_spec_types[6])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecULong"><type>GParamSpecULong</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecULong"/>struct GParamSpecULong</title>
<indexterm><primary>GParamSpecULong</primary></indexterm><programlisting>struct GParamSpecULong {

  GParamSpec    parent_instance;
  
  gulong        minimum;
  gulong        maximum;
  gulong        default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned long integer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gulong">gulong</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gulong">gulong</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gulong">gulong</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-ulong"/>g_param_spec_ulong ()</title>
<indexterm><primary>g_param_spec_ulong</primary></indexterm><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>
Creates a new <link linkend="GParamSpecULong"><type>GParamSpecULong</type></link> instance specifying a <literal>G_TYPE_ULONG</literal> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>  a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-ulong"/>g_value_set_ulong ()</title>
<indexterm><primary>g_value_set_ulong</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_ulong</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_ULONG</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_ulong</parameter>&nbsp;:</term>
<listitem><simpara>unsigned long integer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-ulong"/>g_value_get_ulong ()</title>
<indexterm><primary>g_value_get_ulong</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_ULONG</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>unsigned long integer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-INT64-CAPS"/>G_IS_PARAM_SPEC_INT64()</title>
<indexterm><primary>G_IS_PARAM_SPEC_INT64</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_INT64</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-INT64-CAPS"/>G_PARAM_SPEC_INT64()</title>
<indexterm><primary>G_PARAM_SPEC_INT64</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecInt64"><type>GParamSpecInt64</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-INT64-CAPS"/>G_VALUE_HOLDS_INT64()</title>
<indexterm><primary>G_VALUE_HOLDS_INT64</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_INT64</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-INT64-CAPS"/>G_TYPE_PARAM_INT64</title>
<indexterm><primary>G_TYPE_PARAM_INT64</primary></indexterm><programlisting>#define	G_TYPE_PARAM_INT64		   (g_param_spec_types[7])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecInt64"><type>GParamSpecInt64</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecInt64"/>struct GParamSpecInt64</title>
<indexterm><primary>GParamSpecInt64</primary></indexterm><programlisting>struct GParamSpecInt64 {

  GParamSpec    parent_instance;
  
  gint64        minimum;
  gint64        maximum;
  gint64        default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for 64bit integer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint64">gint64</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint64">gint64</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint64">gint64</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-int64"/>g_param_spec_int64 ()</title>
<indexterm><primary>g_param_spec_int64</primary></indexterm><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>
Creates a new <link linkend="GParamSpecInt64"><type>GParamSpecInt64</type></link> instance specifying a <literal>G_TYPE_INT64</literal> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-int64"/>g_value_set_int64 ()</title>
<indexterm><primary>g_value_set_int64</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_int64</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_INT64</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_int64</parameter>&nbsp;:</term>
<listitem><simpara>64bit integer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-int64"/>g_value_get_int64 ()</title>
<indexterm><primary>g_value_get_int64</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_INT64</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>64bit integer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UINT64-CAPS"/>G_IS_PARAM_SPEC_UINT64()</title>
<indexterm><primary>G_IS_PARAM_SPEC_UINT64</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_UINT64</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UINT64-CAPS"/>G_PARAM_SPEC_UINT64()</title>
<indexterm><primary>G_PARAM_SPEC_UINT64</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecUInt64"><type>GParamSpecUInt64</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-UINT64-CAPS"/>G_VALUE_HOLDS_UINT64()</title>
<indexterm><primary>G_VALUE_HOLDS_UINT64</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_UINT64</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UINT64-CAPS"/>G_TYPE_PARAM_UINT64</title>
<indexterm><primary>G_TYPE_PARAM_UINT64</primary></indexterm><programlisting>#define	G_TYPE_PARAM_UINT64		   (g_param_spec_types[8])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecUInt64"><type>GParamSpecUInt64</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUInt64"/>struct GParamSpecUInt64</title>
<indexterm><primary>GParamSpecUInt64</primary></indexterm><programlisting>struct GParamSpecUInt64 {

  GParamSpec    parent_instance;
  
  guint64       minimum;
  guint64       maximum;
  guint64       default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned 64bit integer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint64">guint64</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint64">guint64</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint64">guint64</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-uint64"/>g_param_spec_uint64 ()</title>
<indexterm><primary>g_param_spec_uint64</primary></indexterm><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>
Creates a new <link linkend="GParamSpecUInt64"><type>GParamSpecUInt64</type></link> instance specifying a <literal>G_TYPE_UINT64</literal> 
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-uint64"/>g_value_set_uint64 ()</title>
<indexterm><primary>g_value_set_uint64</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_uint64</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_UINT64</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_uint64</parameter>&nbsp;:</term>
<listitem><simpara>unsigned 64bit integer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-uint64"/>g_value_get_uint64 ()</title>
<indexterm><primary>g_value_get_uint64</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_UINT64</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>unsigned 64bit integer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-FLOAT-CAPS"/>G_IS_PARAM_SPEC_FLOAT()</title>
<indexterm><primary>G_IS_PARAM_SPEC_FLOAT</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_FLOAT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-FLOAT-CAPS"/>G_PARAM_SPEC_FLOAT()</title>
<indexterm><primary>G_PARAM_SPEC_FLOAT</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecFloat"><type>GParamSpecFloat</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-FLOAT-CAPS"/>G_VALUE_HOLDS_FLOAT()</title>
<indexterm><primary>G_VALUE_HOLDS_FLOAT</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_FLOAT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-FLOAT-CAPS"/>G_TYPE_PARAM_FLOAT</title>
<indexterm><primary>G_TYPE_PARAM_FLOAT</primary></indexterm><programlisting>#define	G_TYPE_PARAM_FLOAT		   (g_param_spec_types[12])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecFloat"><type>GParamSpecFloat</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecFloat"/>struct GParamSpecFloat</title>
<indexterm><primary>GParamSpecFloat</primary></indexterm><programlisting>struct GParamSpecFloat {

  GParamSpec    parent_instance;
  
  gfloat        minimum;
  gfloat        maximum;
  gfloat        default_value;
  gfloat        epsilon;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for float properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link> <structfield>epsilon</structfield></term>
<listitem><simpara>

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-float"/>g_param_spec_float ()</title>
<indexterm><primary>g_param_spec_float</primary></indexterm><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>
Creates a new <link linkend="GParamSpecFloat"><type>GParamSpecFloat</type></link> instance specifying a <literal>G_TYPE_FLOAT</literal> property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-float"/>g_value_set_float ()</title>
<indexterm><primary>g_value_set_float</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_float</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>    a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_FLOAT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_float</parameter>&nbsp;:</term>
<listitem><simpara>float value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-float"/>g_value_get_float ()</title>
<indexterm><primary>g_value_get_float</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_FLOAT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>float contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-DOUBLE-CAPS"/>G_IS_PARAM_SPEC_DOUBLE()</title>
<indexterm><primary>G_IS_PARAM_SPEC_DOUBLE</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_DOUBLE</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-DOUBLE-CAPS"/>G_PARAM_SPEC_DOUBLE()</title>
<indexterm><primary>G_PARAM_SPEC_DOUBLE</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecDouble"><type>GParamSpecDouble</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-DOUBLE-CAPS"/>G_VALUE_HOLDS_DOUBLE()</title>
<indexterm><primary>G_VALUE_HOLDS_DOUBLE</primary></indexterm><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"><type>GValue</type></link> can hold values of type <literal>G_TYPE_DOUBLE</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-DOUBLE-CAPS"/>G_TYPE_PARAM_DOUBLE</title>
<indexterm><primary>G_TYPE_PARAM_DOUBLE</primary></indexterm><programlisting>#define	G_TYPE_PARAM_DOUBLE		   (g_param_spec_types[13])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecDouble"><type>GParamSpecDouble</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecDouble"/>struct GParamSpecDouble</title>
<indexterm><primary>GParamSpecDouble</primary></indexterm><programlisting>struct GParamSpecDouble {

  GParamSpec    parent_instance;
  
  gdouble       minimum;
  gdouble       maximum;
  gdouble       default_value;
  gdouble       epsilon;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for double properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link> <structfield>minimum</structfield></term>
<listitem><simpara>        minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link> <structfield>maximum</structfield></term>
<listitem><simpara>        maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link> <structfield>epsilon</structfield></term>
<listitem><simpara>

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-double"/>g_param_spec_double ()</title>
<indexterm><primary>g_param_spec_double</primary></indexterm><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>
Creates a new <link linkend="GParamSpecDouble"><type>GParamSpecDouble</type></link> instance specifying a <literal>G_TYPE_DOUBLE</literal> 
property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&nbsp;:</term>
<listitem><simpara>      minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&nbsp;:</term>
<listitem><simpara>      maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-double"/>g_value_set_double ()</title>
<indexterm><primary>g_value_set_double</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_double</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>    a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_DOUBLE</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_double</parameter>&nbsp;:</term>
<listitem><simpara>double value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-double"/>g_value_get_double ()</title>
<indexterm><primary>g_value_get_double</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_DOUBLE</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>double contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-ENUM-CAPS"/>G_IS_PARAM_SPEC_ENUM()</title>
<indexterm><primary>G_IS_PARAM_SPEC_ENUM</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_ENUM(pspec)        (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ENUM))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_ENUM</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-ENUM-CAPS"/>G_PARAM_SPEC_ENUM()</title>
<indexterm><primary>G_PARAM_SPEC_ENUM</primary></indexterm><programlisting>#define G_PARAM_SPEC_ENUM(pspec)           (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ENUM, GParamSpecEnum))
</programlisting>
<para>
Cast a <link linkend="GParamSpec"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecEnum"><type>GParamSpecEnum</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-ENUM-CAPS"/>G_VALUE_HOLDS_ENUM()</title>
<indexterm><primary>G_VALUE_HOLDS_ENUM</primary></indexterm><programlisting>#define G_VALUE_HOLDS_ENUM(value)      (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ENUM))
</programlisting>
<para>
Return whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <literal>G_TYPE_ENUM</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-ENUM-CAPS"/>G_TYPE_PARAM_ENUM</title>
<indexterm><primary>G_TYPE_PARAM_ENUM</primary></indexterm><programlisting>#define	G_TYPE_PARAM_ENUM		   (g_param_spec_types[10])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecEnum"><type>GParamSpecEnum</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecEnum"/>struct GParamSpecEnum</title>
<indexterm><primary>GParamSpecEnum</primary></indexterm><programlisting>struct GParamSpecEnum {

  GParamSpec    parent_instance;
  
  GEnumClass   *enum_class;
  gint          default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for enum 
properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="GEnumClass">GEnumClass</link> *<structfield>enum_class</structfield></term>
<listitem><simpara>the <link linkend="GEnumClass"><type>GEnumClass</type></link> for the enum
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint">gint</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-enum"/>g_param_spec_enum ()</title>
<indexterm><primary>g_param_spec_enum</primary></indexterm><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>
Creates a new <link linkend="GParamSpecEnum"><type>GParamSpecEnum</type></link> instance specifying a <literal>G_TYPE_ENUM</literal>
property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>enum_type</parameter>&nbsp;:</term>
<listitem><simpara>    a <link linkend="GType"><type>GType</type></link> derived from <literal>G_TYPE_ENUM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-enum"/>g_value_set_enum ()</title>
<indexterm><primary>g_value_set_enum</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_enum                (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gint">gint</link> v_enum);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_ENUM</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_enum</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_ENUM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_enum</parameter>&nbsp;:</term>
<listitem><simpara>enum value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-enum"/>g_value_get_enum ()</title>
<indexterm><primary>g_value_get_enum</primary></indexterm><programlisting><link linkend="gint">gint</link>        g_value_get_enum                (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_ENUM</literal> <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_ENUM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>enum contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-FLAGS-CAPS"/>G_IS_PARAM_SPEC_FLAGS()</title>
<indexterm><primary>G_IS_PARAM_SPEC_FLAGS</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_FLAGS(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLAGS))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_FLAGS</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-FLAGS-CAPS"/>G_PARAM_SPEC_FLAGS()</title>
<indexterm><primary>G_PARAM_SPEC_FLAGS</primary></indexterm><programlisting>#define G_PARAM_SPEC_FLAGS(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLAGS, GParamSpecFlags))
</programlisting>
<para>
Cast a <link linkend="GParamSpec"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecFlags"><type>GParamSpecFlags</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-FLAGS-CAPS"/>G_VALUE_HOLDS_FLAGS()</title>
<indexterm><primary>G_VALUE_HOLDS_FLAGS</primary></indexterm><programlisting>#define G_VALUE_HOLDS_FLAGS(value)     (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLAGS))
</programlisting>
<para>
Returns whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <literal>G_TYPE_FLAGS</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-FLAGS-CAPS"/>G_TYPE_PARAM_FLAGS</title>
<indexterm><primary>G_TYPE_PARAM_FLAGS</primary></indexterm><programlisting>#define	G_TYPE_PARAM_FLAGS		   (g_param_spec_types[11])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecFlags"><type>GParamSpecFlags</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecFlags"/>struct GParamSpecFlags</title>
<indexterm><primary>GParamSpecFlags</primary></indexterm><programlisting>struct GParamSpecFlags {

  GParamSpec    parent_instance;
  
  GFlagsClass  *flags_class;
  guint         default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for flags
properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="GFlagsClass">GFlagsClass</link> *<structfield>flags_class</structfield></term>
<listitem><simpara>the <link linkend="GFlagsClass"><type>GFlagsClass</type></link> for the flags
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-flags"/>g_param_spec_flags ()</title>
<indexterm><primary>g_param_spec_flags</primary></indexterm><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>
Creates a new <link linkend="GParamSpecEnum"><type>GParamSpecEnum</type></link> instance specifying a <literal>G_TYPE_FLAGS</literal>
property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags_type</parameter>&nbsp;:</term>
<listitem><simpara>    a <link linkend="GType"><type>GType</type></link> derived from <literal>G_TYPE_FLAGS</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-flags"/>g_value_set_flags ()</title>
<indexterm><primary>g_value_set_flags</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_flags               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="guint">guint</link> v_flags);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_FLAGS</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_flags</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_FLAGS</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_flags</parameter>&nbsp;:</term>
<listitem><simpara>flags value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-flags"/>g_value_get_flags ()</title>
<indexterm><primary>g_value_get_flags</primary></indexterm><programlisting><link linkend="guint">guint</link>       g_value_get_flags               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_FLAGS</literal> <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_FLAGS</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>flags contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-STRING-CAPS"/>G_IS_PARAM_SPEC_STRING()</title>
<indexterm><primary>G_IS_PARAM_SPEC_STRING</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_STRING(pspec)      (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_STRING))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_STRING</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-STRING-CAPS"/>G_PARAM_SPEC_STRING()</title>
<indexterm><primary>G_PARAM_SPEC_STRING</primary></indexterm><programlisting>#define G_PARAM_SPEC_STRING(pspec)         (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_STRING, GParamSpecString))
</programlisting>
<para>
Casts a <link linkend="GParamSpec"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecString"><type>GParamSpecString</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-STRING-CAPS"/>G_VALUE_HOLDS_STRING()</title>
<indexterm><primary>G_VALUE_HOLDS_STRING</primary></indexterm><programlisting>#define G_VALUE_HOLDS_STRING(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_STRING))
</programlisting>
<para>
Return whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <literal>G_TYPE_STRING</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-STRING-CAPS"/>G_TYPE_PARAM_STRING</title>
<indexterm><primary>G_TYPE_PARAM_STRING</primary></indexterm><programlisting>#define	G_TYPE_PARAM_STRING		   (g_param_spec_types[14])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecString"><type>GParamSpecString</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecString"/>struct GParamSpecString</title>
<indexterm><primary>GParamSpecString</primary></indexterm><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>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for string
properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gchar">gchar</link> *<structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gchar">gchar</link> *<structfield>cset_first</structfield></term>
<listitem><simpara>a string containing the allowed values for the first byte
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gchar">gchar</link> *<structfield>cset_nth</structfield></term>
<listitem><simpara>a string containing the allowed values for the subsequent bytes
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gchar">gchar</link> <structfield>substitutor</structfield></term>
<listitem><simpara>the replacement byte for bytes which don't match <parameter>cset_first</parameter> or <parameter>cset_nth</parameter>.
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>null_fold_if_empty</structfield> : 1</term>
<listitem><simpara>replace empty string by <literal>NULL</literal>
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>ensure_non_null</structfield> : 1</term>
<listitem><simpara> replace <literal>NULL</literal> strings by an empty string

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="gchararray"/>gchararray</title>
<indexterm><primary>gchararray</primary></indexterm><programlisting>typedef gchar* gchararray;
</programlisting>
<para>
A C representable type name for <link linkend="G-TYPE-STRING-CAPS"><type>G_TYPE_STRING</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-string"/>g_param_spec_string ()</title>
<indexterm><primary>g_param_spec_string</primary></indexterm><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>
Creates a new <link linkend="GParamSpecString"><type>GParamSpecString</type></link> instance.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-string"/>g_value_set_string ()</title>
<indexterm><primary>g_value_set_string</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_string              (<link linkend="GValue">GValue</link> *value,
                                             const <link linkend="gchar">gchar</link> *v_string);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_STRING</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_string</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_STRING</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&nbsp;:</term>
<listitem><simpara>string to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-static-string"/>g_value_set_static_string ()</title>
<indexterm><primary>g_value_set_static_string</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_static_string       (<link linkend="GValue">GValue</link> *value,
                                             const <link linkend="gchar">gchar</link> *v_string);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_STRING</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_string</parameter>.
The string is assumed to be static, and is thus not duplicated
when setting the <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_STRING</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&nbsp;:</term>
<listitem><simpara>static string to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-take-string"/>g_value_take_string ()</title>
<indexterm role="2.4"><primary>g_value_take_string</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_take_string             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> *v_string);</programlisting>
<para>
Sets the contents of a <literal>G_TYPE_STRING</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_string</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_STRING</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&nbsp;:</term>
<listitem><simpara>duplicated unowned string to be set
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="g-value-set-string-take-ownership"/>g_value_set_string_take_ownership ()</title>
<indexterm role="deprecated"><primary>g_value_set_string_take_ownership</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_string_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gchar">gchar</link> *v_string);</programlisting>
<warning><para><literal>g_value_set_string_take_ownership</literal> is deprecated and should not be used in newly-written code. Use <link linkend="g-value-take-string"><function>g_value_take_string()</function></link> instead.</para></warning>
<para>
This is an internal function introduced mainly for C marshallers.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_STRING</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&nbsp;:</term>
<listitem><simpara>duplicated unowned string to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-string"/>g_value_get_string ()</title>
<indexterm><primary>g_value_get_string</primary></indexterm><programlisting>G_CONST_RETURN <link linkend="gchar">gchar</link>* g_value_get_string    (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_STRING</literal> <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_STRING</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>string content of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-dup-string"/>g_value_dup_string ()</title>
<indexterm><primary>g_value_dup_string</primary></indexterm><programlisting><link linkend="gchar">gchar</link>*      g_value_dup_string              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get a copy the contents of a <literal>G_TYPE_STRING</literal> <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_STRING</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly allocated copy of the string content of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-PARAM-CAPS"/>G_IS_PARAM_SPEC_PARAM()</title>
<indexterm><primary>G_IS_PARAM_SPEC_PARAM</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_PARAM(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_PARAM))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_PARAM</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-PARAM-CAPS"/>G_PARAM_SPEC_PARAM()</title>
<indexterm><primary>G_PARAM_SPEC_PARAM</primary></indexterm><programlisting>#define G_PARAM_SPEC_PARAM(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_PARAM, GParamSpecParam))
</programlisting>
<para>
Casts a <link linkend="GParamSpec"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecParam"><type>GParamSpecParam</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-PARAM-CAPS"/>G_VALUE_HOLDS_PARAM()</title>
<indexterm><primary>G_VALUE_HOLDS_PARAM</primary></indexterm><programlisting>#define G_VALUE_HOLDS_PARAM(value)	(G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_PARAM))
</programlisting>
<para>
Return whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <literal>G_TYPE_PARAM</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-PARAM-CAPS"/>G_TYPE_PARAM_PARAM</title>
<indexterm><primary>G_TYPE_PARAM_PARAM</primary></indexterm><programlisting>#define	G_TYPE_PARAM_PARAM		   (g_param_spec_types[15])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecParam"><type>GParamSpecParam</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecParam"/>struct GParamSpecParam</title>
<indexterm><primary>GParamSpecParam</primary></indexterm><programlisting>struct GParamSpecParam {

  GParamSpec    parent_instance;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for <literal>G_TYPE_PARAM</literal>
properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-param"/>g_param_spec_param ()</title>
<indexterm><primary>g_param_spec_param</primary></indexterm><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>
Creates a new <link linkend="GParamSpecParam"><type>GParamSpecParam</type></link> instance specifying a <literal>G_TYPE_PARAM</literal>
property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param_type</parameter>&nbsp;:</term>
<listitem><simpara>   a <link linkend="GType"><type>GType</type></link> derived from <literal>G_TYPE_PARAM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-param"/>g_value_set_param ()</title>
<indexterm><primary>g_value_set_param</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_param               (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_PARAM</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>param</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_PARAM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param</parameter>&nbsp;:</term>
<listitem><simpara>the <link linkend="GParamSpec"><type>GParamSpec</type></link> to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-take-param"/>g_value_take_param ()</title>
<indexterm role="2.4"><primary>g_value_take_param</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_take_param              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);</programlisting>
<para>
Sets the contents of a <literal>G_TYPE_PARAM</literal> <link linkend="GValue"><type>GValue</type></link> to <parameter>param</parameter> and
takes over the ownership of the callers reference to <parameter>param</parameter>; 
the caller doesn't have to unref it any more.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_PARAM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param</parameter>&nbsp;:</term>
<listitem><simpara>the <link linkend="GParamSpec"><type>GParamSpec</type></link> to be set
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="g-value-set-param-take-ownership"/>g_value_set_param_take_ownership ()</title>
<indexterm role="deprecated"><primary>g_value_set_param_take_ownership</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_param_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="GParamSpec">GParamSpec</link> *param);</programlisting>
<warning><para><literal>g_value_set_param_take_ownership</literal> is deprecated and should not be used in newly-written code. Use <link linkend="g-value-take-param"><function>g_value_take_param()</function></link> instead.</para></warning>
<para>
This is an internal function introduced mainly for C marshallers.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <literal>G_TYPE_PARAM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param</parameter>&nbsp;:</term>
<listitem><simpara>the <link linkend="GParamSpec"><type>GParamSpec</type></link> to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-param"/>g_value_get_param ()</title>
<indexterm><primary>g_value_get_param</primary></indexterm><programlisting><link linkend="GParamSpec">GParamSpec</link>* g_value_get_param               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_PARAM</literal> <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_PARAM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara><link linkend="GParamSpec"><type>GParamSpec</type></link> content of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-dup-param"/>g_value_dup_param ()</title>
<indexterm><primary>g_value_dup_param</primary></indexterm><programlisting><link linkend="GParamSpec">GParamSpec</link>* g_value_dup_param               (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_PARAM</literal> <link linkend="GValue"><type>GValue</type></link>, increasing its reference count.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_PARAM</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara><link linkend="GParamSpec"><type>GParamSpec</type></link> content of <parameter>value</parameter>, should be unreferenced when no longer needed.


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-BOXED-CAPS"/>G_IS_PARAM_SPEC_BOXED()</title>
<indexterm><primary>G_IS_PARAM_SPEC_BOXED</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_BOXED</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-BOXED-CAPS"/>G_PARAM_SPEC_BOXED()</title>
<indexterm><primary>G_PARAM_SPEC_BOXED</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecBoxed"><type>GParamSpecBoxed</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-BOXED-CAPS"/>G_VALUE_HOLDS_BOXED()</title>
<indexterm><primary>G_VALUE_HOLDS_BOXED</primary></indexterm><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"><type>GValue</type></link> can hold values derived from type <literal>G_TYPE_BOXED</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-BOXED-CAPS"/>G_TYPE_PARAM_BOXED</title>
<indexterm><primary>G_TYPE_PARAM_BOXED</primary></indexterm><programlisting>#define	G_TYPE_PARAM_BOXED		   (g_param_spec_types[16])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecBoxed"><type>GParamSpecBoxed</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecBoxed"/>struct GParamSpecBoxed</title>
<indexterm><primary>GParamSpecBoxed</primary></indexterm><programlisting>struct GParamSpecBoxed {

  GParamSpec    parent_instance;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for boxed properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-boxed"/>g_param_spec_boxed ()</title>
<indexterm><primary>g_param_spec_boxed</primary></indexterm><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>
Creates a new <link linkend="GParamSpecBoxed"><type>GParamSpecBoxed</type></link> instance specifying a <literal>G_TYPE_BOXED</literal> 
derived property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>boxed_type</parameter>&nbsp;:</term>
<listitem><simpara>   <literal>G_TYPE_BOXED</literal> derived type of this property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-boxed"/>g_value_set_boxed ()</title>
<indexterm><primary>g_value_set_boxed</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></link> to <parameter>v_boxed</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_BOXED</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&nbsp;:</term>
<listitem><simpara>boxed value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-static-boxed"/>g_value_set_static_boxed ()</title>
<indexterm><primary>g_value_set_static_boxed</primary></indexterm><programlisting><link linkend="void">void</link>        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"><type>GValue</type></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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_BOXED</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&nbsp;:</term>
<listitem><simpara>static boxed value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-take-boxed"/>g_value_take_boxed ()</title>
<indexterm role="2.4"><primary>g_value_take_boxed</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_take_boxed              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);</programlisting>
<para>
Sets the contents of a <literal>G_TYPE_BOXED</literal> derived <link linkend="GValue"><type>GValue</type></link> to <parameter>v_boxed</parameter> and
takes over the ownership of the callers reference to <parameter>v_boxed</parameter>; 
the caller doesn't have to unref it any more.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_BOXED</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&nbsp;:</term>
<listitem><simpara>duplicated unowned boxed value to be set
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="g-value-set-boxed-take-ownership"/>g_value_set_boxed_take_ownership ()</title>
<indexterm role="deprecated"><primary>g_value_set_boxed_take_ownership</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_boxed_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gconstpointer">gconstpointer</link> v_boxed);</programlisting>
<warning><para><literal>g_value_set_boxed_take_ownership</literal> is deprecated and should not be used in newly-written code. Use <link linkend="g-value-take-boxed"><function>g_value_take_boxed()</function></link> instead.</para></warning>
<para>
This is an internal function introduced mainly for C marshallers.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_BOXED</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&nbsp;:</term>
<listitem><simpara>duplicated unowned boxed value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-boxed"/>g_value_get_boxed ()</title>
<indexterm><primary>g_value_get_boxed</primary></indexterm><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"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_BOXED</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>boxed contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-dup-boxed"/>g_value_dup_boxed ()</title>
<indexterm><primary>g_value_dup_boxed</primary></indexterm><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"><type>GValue</type></link>.
Upon getting, the boxed value is duplicated and needs to be
later freed with <link linkend="g-boxed-free"><function>g_boxed_free()</function></link>, e.g. like: g_boxed_free (G_VALUE_TYPE (<parameter>value</parameter>), return_value);
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_BOXED</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>boxed contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-POINTER-CAPS"/>G_IS_PARAM_SPEC_POINTER()</title>
<indexterm><primary>G_IS_PARAM_SPEC_POINTER</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_POINTER(pspec)     (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_POINTER))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_POINTER</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-POINTER-CAPS"/>G_PARAM_SPEC_POINTER()</title>
<indexterm><primary>G_PARAM_SPEC_POINTER</primary></indexterm><programlisting>#define G_PARAM_SPEC_POINTER(pspec)        (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_POINTER, GParamSpecPointer))
</programlisting>
<para>
Casts a <link linkend="GParamSpec"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecPointer"><type>GParamSpecPointer</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-POINTER-CAPS"/>G_VALUE_HOLDS_POINTER()</title>
<indexterm><primary>G_VALUE_HOLDS_POINTER</primary></indexterm><programlisting>#define G_VALUE_HOLDS_POINTER(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_POINTER))
</programlisting>
<para>
Return whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <literal>G_TYPE_POINTER</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-POINTER-CAPS"/>G_TYPE_PARAM_POINTER</title>
<indexterm><primary>G_TYPE_PARAM_POINTER</primary></indexterm><programlisting>#define	G_TYPE_PARAM_POINTER		   (g_param_spec_types[17])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecPointer"><type>GParamSpecPointer</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecPointer"/>struct GParamSpecPointer</title>
<indexterm><primary>GParamSpecPointer</primary></indexterm><programlisting>struct GParamSpecPointer {

  GParamSpec    parent_instance;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for pointer properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-pointer"/>g_param_spec_pointer ()</title>
<indexterm><primary>g_param_spec_pointer</primary></indexterm><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>
Creates a new <link linkend="GParamSpecPoiner"><type>GParamSpecPoiner</type></link> instance specifying a pointer property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-pointer"/>g_value_set_pointer ()</title>
<indexterm><primary>g_value_set_pointer</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_pointer             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_pointer);</programlisting>
<para>
Set the contents of a pointer <link linkend="GValue"><type>GValue</type></link> to <parameter>v_pointer</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_POINTER</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_pointer</parameter>&nbsp;:</term>
<listitem><simpara>pointer value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-pointer"/>g_value_get_pointer ()</title>
<indexterm><primary>g_value_get_pointer</primary></indexterm><programlisting><link linkend="gpointer">gpointer</link>    g_value_get_pointer             (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a pointer <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_POINTER</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>pointer contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-OBJECT-CAPS"/>G_IS_PARAM_SPEC_OBJECT()</title>
<indexterm><primary>G_IS_PARAM_SPEC_OBJECT</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_OBJECT(pspec)      (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OBJECT))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_OBJECT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-OBJECT-CAPS"/>G_PARAM_SPEC_OBJECT()</title>
<indexterm><primary>G_PARAM_SPEC_OBJECT</primary></indexterm><programlisting>#define G_PARAM_SPEC_OBJECT(pspec)         (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OBJECT, GParamSpecObject))
</programlisting>
<para>
Casts a <link linkend="GParamSpec"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecObject"><type>GParamSpecObject</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-VALUE-HOLDS-OBJECT-CAPS"/>G_VALUE_HOLDS_OBJECT()</title>
<indexterm><primary>G_VALUE_HOLDS_OBJECT</primary></indexterm><programlisting>#define G_VALUE_HOLDS_OBJECT(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_OBJECT))
</programlisting>
<para>
Return whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <literal>G_TYPE_OBJECT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> structure


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-OBJECT-CAPS"/>G_TYPE_PARAM_OBJECT</title>
<indexterm><primary>G_TYPE_PARAM_OBJECT</primary></indexterm><programlisting>#define	G_TYPE_PARAM_OBJECT		   (g_param_spec_types[19])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecObject"><type>GParamSpecObject</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecObject"/>struct GParamSpecObject</title>
<indexterm><primary>GParamSpecObject</primary></indexterm><programlisting>struct GParamSpecObject {

  GParamSpec    parent_instance;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for object properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-object"/>g_param_spec_object ()</title>
<indexterm><primary>g_param_spec_object</primary></indexterm><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>
Creates a new <link linkend="GParamSpecBoxed"><type>GParamSpecBoxed</type></link> instance specifying a <literal>G_TYPE_OBJECT</literal> 
derived property.
</para>
<para> 
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>object_type</parameter>&nbsp;:</term>
<listitem><simpara>  <literal>G_TYPE_OBJECT</literal> derived type of this property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-set-object"/>g_value_set_object ()</title>
<indexterm><primary>g_value_set_object</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_object              (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);</programlisting>
<para>
Set the contents of a <literal>G_TYPE_OBJECT</literal> derived <link linkend="GValue"><type>GValue</type></link> to <parameter>v_object</parameter>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_OBJECT</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_object</parameter>&nbsp;:</term>
<listitem><simpara>object value to be set


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-take-object"/>g_value_take_object ()</title>
<indexterm role="2.4"><primary>g_value_take_object</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_take_object             (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);</programlisting>
<para>
Sets the contents of a <literal>G_TYPE_OBJECT</literal> derived <link linkend="GValue"><type>GValue</type></link> to <parameter>v_object</parameter> 
and takes over the ownership of the callers reference to <parameter>v_object</parameter>; 
the caller doesn't have to unref it any more.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_OBJECT</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_object</parameter>&nbsp;:</term>
<listitem><simpara>object value to be set
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="g-value-set-object-take-ownership"/>g_value_set_object_take_ownership ()</title>
<indexterm role="deprecated"><primary>g_value_set_object_take_ownership</primary></indexterm><programlisting><link linkend="void">void</link>        g_value_set_object_take_ownership
                                            (<link linkend="GValue">GValue</link> *value,
                                             <link linkend="gpointer">gpointer</link> v_object);</programlisting>
<warning><para><literal>g_value_set_object_take_ownership</literal> is deprecated and should not be used in newly-written code. Use <link linkend="g-value-take-object"><function>g_value_take_object()</function></link> instead.</para></warning>
<para>
This is an internal function introduced mainly for C marshallers.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_OBJECT</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_object</parameter>&nbsp;:</term>
<listitem><simpara>object value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-get-object"/>g_value_get_object ()</title>
<indexterm><primary>g_value_get_object</primary></indexterm><programlisting><link linkend="gpointer">gpointer</link>    g_value_get_object              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_OBJECT</literal> derived <link linkend="GValue"><type>GValue</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>  a valid <link linkend="GValue"><type>GValue</type></link> of <literal>G_TYPE_OBJECT</literal> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>object contents of <parameter>value</parameter>


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-value-dup-object"/>g_value_dup_object ()</title>
<indexterm><primary>g_value_dup_object</primary></indexterm><programlisting><link linkend="GObject">GObject</link>*    g_value_dup_object              (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <literal>G_TYPE_OBJECT</literal> derived <link linkend="GValue"><type>GValue</type></link>, increasing its reference count.
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <literal>G_TYPE_OBJECT</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>object content of <parameter>value</parameter>, should be unreferenced when no longer needed.


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-UNICHAR-CAPS"/>G_IS_PARAM_SPEC_UNICHAR()</title>
<indexterm><primary>G_IS_PARAM_SPEC_UNICHAR</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_UNICHAR</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-UNICHAR-CAPS"/>G_PARAM_SPEC_UNICHAR()</title>
<indexterm><primary>G_PARAM_SPEC_UNICHAR</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecUnichar"><type>GParamSpecUnichar</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-UNICHAR-CAPS"/>G_TYPE_PARAM_UNICHAR</title>
<indexterm><primary>G_TYPE_PARAM_UNICHAR</primary></indexterm><programlisting>#define	G_TYPE_PARAM_UNICHAR		   (g_param_spec_types[9])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecUnichar"><type>GParamSpecUnichar</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecUnichar"/>struct GParamSpecUnichar</title>
<indexterm><primary>GParamSpecUnichar</primary></indexterm><programlisting>struct GParamSpecUnichar {

  GParamSpec    parent_instance;
  
  gunichar      default_value;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unichar (unsigned integer) properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara>private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gunichar">gunichar</link> <structfield>default_value</structfield></term>
<listitem><simpara>  default value for the property specified

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-unichar"/>g_param_spec_unichar ()</title>
<indexterm><primary>g_param_spec_unichar</primary></indexterm><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>
Creates a new <link linkend="GParamSpecUnichar"><type>GParamSpecUnichar</type></link> instance specifying a <literal>G_TYPE_UINT</literal> 
property. <link linkend="GValue"><type>GValue</type></link> structures for this property can be accessed with 
<link linkend="g-value-set-uint"><function>g_value_set_uint()</function></link> and <link linkend="g-value-get-uint"><function>g_value_get_uint()</function></link>.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&nbsp;:</term>
<listitem><simpara>default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-VALUE-ARRAY-CAPS"/>G_IS_PARAM_SPEC_VALUE_ARRAY()</title>
<indexterm><primary>G_IS_PARAM_SPEC_VALUE_ARRAY</primary></indexterm><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"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_VALUE_ARRAY</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-VALUE-ARRAY-CAPS"/>G_PARAM_SPEC_VALUE_ARRAY()</title>
<indexterm><primary>G_PARAM_SPEC_VALUE_ARRAY</primary></indexterm><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"><type>GParamSpec</type></link> instance into a <link linkend="GParamSpecValueArray"><type>GParamSpecValueArray</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-VALUE-ARRAY-CAPS"/>G_TYPE_PARAM_VALUE_ARRAY</title>
<indexterm><primary>G_TYPE_PARAM_VALUE_ARRAY</primary></indexterm><programlisting>#define	G_TYPE_PARAM_VALUE_ARRAY	   (g_param_spec_types[18])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecValueArray"><type>GParamSpecValueArray</type></link>.
</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecValueArray"/>struct GParamSpecValueArray</title>
<indexterm><primary>GParamSpecValueArray</primary></indexterm><programlisting>struct GParamSpecValueArray {

  GParamSpec    parent_instance;
  GParamSpec   *element_spec;
  guint		fixed_n_elements;
};
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for <link linkend="GValueArray"><type>GValueArray</type></link> properties.
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> <structfield>parent_instance</structfield></term>
<listitem><simpara> private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link> *<structfield>element_spec</structfield></term>
<listitem><simpara>    a <link linkend="GParamSpec"><type>GParamSpec</type></link> describing the elements contained in arrays of this property, may be <literal>NULL</literal>
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link> <structfield>fixed_n_elements</structfield></term>
<listitem><simpara>if greater than 0, arrays of this property will always have this many elements

</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="g-param-spec-value-array"/>g_param_spec_value_array ()</title>
<indexterm><primary>g_param_spec_value_array</primary></indexterm><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>
Creates a new <link linkend="GParamSpecValueArray"><type>GParamSpecValueArray</type></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"><type>GValue</type></link> structures for this property can be accessed 
with <link linkend="g-value-set-boxed"><function>g_value_set_boxed()</function></link> and <link linkend="g-value-get-boxed"><function>g_value_get_boxed()</function></link>.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>         canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&nbsp;:</term>
<listitem><simpara>         nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&nbsp;:</term>
<listitem><simpara>        description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>element_spec</parameter>&nbsp;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link> describing the elements contained in 
                arrays of this property, may be <literal>NULL</literal>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&nbsp;:</term>
<listitem><simpara>        flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>a newly created parameter specification


</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2>
<title><anchor id="G-IS-PARAM-SPEC-OVERRIDE-CAPS"/>G_IS_PARAM_SPEC_OVERRIDE()</title>
<indexterm role="2.4"><primary>G_IS_PARAM_SPEC_OVERRIDE</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_OVERRIDE(pspec)    (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OVERRIDE))
</programlisting>
<para>
Returns whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <literal>G_TYPE_PARAM_OBJECT</literal>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara>a <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="G-PARAM-SPEC-OVERRIDE-CAPS"/>G_PARAM_SPEC_OVERRIDE()</title>
<indexterm role="2.4"><primary>G_PARAM_SPEC_OVERRIDE</primary></indexterm><programlisting>#define G_PARAM_SPEC_OVERRIDE(pspec)       (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OVERRIDE, GParamSpecOverride))
</programlisting>
<para>
Casts a <link linkend="GParamSpec"><type>GParamSpec</type></link> into a <link linkend="GParamSpecObject"><type>GParamSpecObject</type></link>.
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&nbsp;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="G-TYPE-PARAM-OVERRIDE-CAPS"/>G_TYPE_PARAM_OVERRIDE</title>
<indexterm role="2.4"><primary>G_TYPE_PARAM_OVERRIDE</primary></indexterm><programlisting>#define	G_TYPE_PARAM_OVERRIDE		   (g_param_spec_types[20])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecOverride"><type>GParamSpecOverride</type></link>.
</para><para>Since 2.4


</para></refsect2>
<refsect2>
<title><anchor id="GParamSpecOverride"/>struct GParamSpecOverride</title>
<indexterm role="2.4"><primary>GParamSpecOverride</primary></indexterm><programlisting>struct GParamSpecOverride {

};
</programlisting>
<para>
This is a type of <link linkend="GParamSpec"><type>GParamSpec</type></link> type that simply redirects operations to
another paramspec.  All operations other than getting or
setting the value are redirected, including accessing the nick and
blurb, validating a value, and so forth. See
<link linkend="g-param-spec-get-redirect-target"><function>g_param_spec_get_redirect_target()</function></link> for retrieving the overidden
property. <link linkend="GParamSpecOverride"><type>GParamSpecOverride</type></link> is used in implementing
<link linkend="g-object-class-override-property"><function>g_object_class_override_property()</function></link>, and will not be directly useful
unless you are implementing a new base type similar to GObject.
</para><para>Since 2.4

</para></refsect2>
<refsect2>
<title><anchor id="g-param-spec-override"/>g_param_spec_override ()</title>
<indexterm role="2.4"><primary>g_param_spec_override</primary></indexterm><programlisting><link linkend="GParamSpec">GParamSpec</link>* g_param_spec_override           (const <link linkend="gchar">gchar</link> *name,
                                             <link linkend="GParamSpec">GParamSpec</link> *overridden);</programlisting>
<para>
Creates a new property of type <link linkend="GParamSpecOverride"><type>GParamSpecOverride</type></link>. This is used
to direct operations to another paramspec, and will not be directly
useful unless you are implementing a new base type similar to GObject.
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&nbsp;:</term>
<listitem><simpara>the name of the property.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>overridden</parameter>&nbsp;:</term>
<listitem><simpara>The property that is being overridden
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis> :</term><listitem><simpara>the newly created <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para>Since 2.4


</para></refsect2>

</refsect1>



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

</refentry>
