<refentry id="gobject-Standard-Parameter-and-Value-Types">
<refmeta>
<refentrytitle role="top_of_page" id="gobject-Standard-Parameter-and-Value-Types.top_of_page">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 id="gobject-Standard-Parameter-and-Value-Types.synopsis" role="synopsis">
<title role="synopsis.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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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>
                    <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);
const <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>
                    <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>
                    <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>
                    <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>
                    <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="gpointer">gpointer</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>
                    <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>
                    <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>
                    <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);

#define             <link linkend="G-IS-PARAM-SPEC-GTYPE--CAPS">G_IS_PARAM_SPEC_GTYPE</link>               (pspec)
#define             <link linkend="G-PARAM-SPEC-GTYPE--CAPS">G_PARAM_SPEC_GTYPE</link>                  (pspec)
#define             <link linkend="G-VALUE-HOLDS-GTYPE--CAPS">G_VALUE_HOLDS_GTYPE</link>                 (value)
#define             <link linkend="G-TYPE-PARAM-GTYPE--CAPS">G_TYPE_PARAM_GTYPE</link>
                    <link linkend="GParamSpecGType">GParamSpecGType</link>;
<link linkend="GParamSpec">GParamSpec</link>*         <link linkend="g-param-spec-gtype">g_param_spec_gtype</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> is_a_type,
                                                         <link linkend="GParamFlags">GParamFlags</link> flags);
<link linkend="GType">GType</link>               <link linkend="g-value-get-gtype">g_value_get_gtype</link>                   (const <link linkend="GValue">GValue</link> *value);
<link linkend="void">void</link>                <link linkend="g-value-set-gtype">g_value_set_gtype</link>                   (<link linkend="GValue">GValue</link> *value,
                                                         <link linkend="GType">GType</link> v_gtype);
</synopsis>
</refsynopsisdiv>









<refsect1 id="gobject-Standard-Parameter-and-Value-Types.description" role="desc">
<title role="desc.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>
<para>
Parameter names need to start with a letter (a-z or A-Z). Subsequent
characters can be letters, numbers or a '-'.
All other characters are replaced by a '-' during construction.</para>
<para>
</para>
</refsect1>

<refsect1 id="gobject-Standard-Parameter-and-Value-Types.details" role="details">
<title role="details.title">Details</title>
<refsect2 id="G-IS-PARAM-SPEC-BOOLEAN--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_BOOLEAN()</title>
<indexterm zone="G-IS-PARAM-SPEC-BOOLEAN--CAPS"><primary sortas="IS_PARAM_SPEC_BOOLEAN">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-BOOLEAN--CAPS"><literal>G_TYPE_PARAM_BOOLEAN</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-BOOLEAN--CAPS" role="macro">
<title>G_PARAM_SPEC_BOOLEAN()</title>
<indexterm zone="G-PARAM-SPEC-BOOLEAN--CAPS"><primary sortas="PARAM_SPEC_BOOLEAN">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-BOOLEAN--CAPS" role="macro">
<title>G_VALUE_HOLDS_BOOLEAN()</title>
<indexterm zone="G-VALUE-HOLDS-BOOLEAN--CAPS"><primary sortas="VALUE_HOLDS_BOOLEAN">G_VALUE_HOLDS_BOOLEAN</primary></indexterm><programlisting>#define G_VALUE_HOLDS_BOOLEAN(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOOLEAN))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-BOOLEAN--CAPS"><literal>G_TYPE_BOOLEAN</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-BOOLEAN--CAPS" role="macro">
<title>G_TYPE_PARAM_BOOLEAN</title>
<indexterm zone="G-TYPE-PARAM-BOOLEAN--CAPS"><primary sortas="TYPE_PARAM_BOOLEAN">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecBoolean" role="struct">
<title>GParamSpecBoolean</title>
<indexterm zone="GParamSpecBoolean"><primary sortas="ParamSpecBoolean">GParamSpecBoolean</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gboolean      default_value;
} GParamSpecBoolean;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for boolean properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-boolean" role="function">
<title>g_param_spec_boolean ()</title>
<indexterm zone="g-param-spec-boolean"><primary sortas="param_spec_boolean">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 <link linkend="G-TYPE-BOOLEAN--CAPS"><literal>G_TYPE_BOOLEAN</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-boolean" role="function">
<title>g_value_set_boolean ()</title>
<indexterm zone="g-value-set-boolean"><primary sortas="value_set_boolean">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 <link linkend="G-TYPE-BOOLEAN--CAPS"><literal>G_TYPE_BOOLEAN</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_boolean</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-BOOLEAN--CAPS"><literal>G_TYPE_BOOLEAN</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boolean</parameter>&#160;:</term>
<listitem><simpara> boolean value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-boolean" role="function">
<title>g_value_get_boolean ()</title>
<indexterm zone="g-value-get-boolean"><primary sortas="value_get_boolean">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 <link linkend="G-TYPE-BOOLEAN--CAPS"><literal>G_TYPE_BOOLEAN</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-BOOLEAN--CAPS"><literal>G_TYPE_BOOLEAN</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> boolean contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-CHAR--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_CHAR()</title>
<indexterm zone="G-IS-PARAM-SPEC-CHAR--CAPS"><primary sortas="IS_PARAM_SPEC_CHAR">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-CHAR--CAPS"><literal>G_TYPE_PARAM_CHAR</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-CHAR--CAPS" role="macro">
<title>G_PARAM_SPEC_CHAR()</title>
<indexterm zone="G-PARAM-SPEC-CHAR--CAPS"><primary sortas="PARAM_SPEC_CHAR">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-CHAR--CAPS" role="macro">
<title>G_VALUE_HOLDS_CHAR()</title>
<indexterm zone="G-VALUE-HOLDS-CHAR--CAPS"><primary sortas="VALUE_HOLDS_CHAR">G_VALUE_HOLDS_CHAR</primary></indexterm><programlisting>#define G_VALUE_HOLDS_CHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_CHAR))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-CHAR--CAPS"><literal>G_TYPE_CHAR</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-CHAR--CAPS" role="macro">
<title>G_TYPE_PARAM_CHAR</title>
<indexterm zone="G-TYPE-PARAM-CHAR--CAPS"><primary sortas="TYPE_PARAM_CHAR">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecChar" role="struct">
<title>GParamSpecChar</title>
<indexterm zone="GParamSpecChar"><primary sortas="ParamSpecChar">GParamSpecChar</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gint8         minimum;
  gint8         maximum;
  gint8         default_value;
} GParamSpecChar;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for character properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint8">gint8</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint8">gint8</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-char" role="function">
<title>g_param_spec_char ()</title>
<indexterm zone="g-param-spec-char"><primary sortas="param_spec_char">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 <link linkend="G-TYPE-CHAR--CAPS"><literal>G_TYPE_CHAR</literal></link> property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-char" role="function">
<title>g_value_set_char ()</title>
<indexterm zone="g-value-set-char"><primary sortas="value_set_char">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 <link linkend="G-TYPE-CHAR--CAPS"><literal>G_TYPE_CHAR</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_char</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-CHAR--CAPS"><literal>G_TYPE_CHAR</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_char</parameter>&#160;:</term>
<listitem><simpara> character value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-char" role="function">
<title>g_value_get_char ()</title>
<indexterm zone="g-value-get-char"><primary sortas="value_get_char">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 <link linkend="G-TYPE-CHAR--CAPS"><literal>G_TYPE_CHAR</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-CHAR--CAPS"><literal>G_TYPE_CHAR</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> character contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-UCHAR--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_UCHAR()</title>
<indexterm zone="G-IS-PARAM-SPEC-UCHAR--CAPS"><primary sortas="IS_PARAM_SPEC_UCHAR">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-UCHAR--CAPS"><literal>G_TYPE_PARAM_UCHAR</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-UCHAR--CAPS" role="macro">
<title>G_PARAM_SPEC_UCHAR()</title>
<indexterm zone="G-PARAM-SPEC-UCHAR--CAPS"><primary sortas="PARAM_SPEC_UCHAR">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-UCHAR--CAPS" role="macro">
<title>G_VALUE_HOLDS_UCHAR()</title>
<indexterm zone="G-VALUE-HOLDS-UCHAR--CAPS"><primary sortas="VALUE_HOLDS_UCHAR">G_VALUE_HOLDS_UCHAR</primary></indexterm><programlisting>#define G_VALUE_HOLDS_UCHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UCHAR))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-UCHAR--CAPS"><literal>G_TYPE_UCHAR</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-UCHAR--CAPS" role="macro">
<title>G_TYPE_PARAM_UCHAR</title>
<indexterm zone="G-TYPE-PARAM-UCHAR--CAPS"><primary sortas="TYPE_PARAM_UCHAR">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecUChar" role="struct">
<title>GParamSpecUChar</title>
<indexterm zone="GParamSpecUChar"><primary sortas="ParamSpecUChar">GParamSpecUChar</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  guint8        minimum;
  guint8        maximum;
  guint8        default_value;
} GParamSpecUChar;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned character properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint8">guint8</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint8">guint8</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-uchar" role="function">
<title>g_param_spec_uchar ()</title>
<indexterm zone="g-param-spec-uchar"><primary sortas="param_spec_uchar">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 <link linkend="G-TYPE-UCHAR--CAPS"><literal>G_TYPE_UCHAR</literal></link> property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-uchar" role="function">
<title>g_value_set_uchar ()</title>
<indexterm zone="g-value-set-uchar"><primary sortas="value_set_uchar">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 <link linkend="G-TYPE-UCHAR--CAPS"><literal>G_TYPE_UCHAR</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_uchar</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-UCHAR--CAPS"><literal>G_TYPE_UCHAR</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_uchar</parameter>&#160;:</term>
<listitem><simpara> unsigned character value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-uchar" role="function">
<title>g_value_get_uchar ()</title>
<indexterm zone="g-value-get-uchar"><primary sortas="value_get_uchar">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 <link linkend="G-TYPE-UCHAR--CAPS"><literal>G_TYPE_UCHAR</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-UCHAR--CAPS"><literal>G_TYPE_UCHAR</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> unsigned character contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-INT--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_INT()</title>
<indexterm zone="G-IS-PARAM-SPEC-INT--CAPS"><primary sortas="IS_PARAM_SPEC_INT">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-INT--CAPS"><literal>G_TYPE_PARAM_INT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-INT--CAPS" role="macro">
<title>G_PARAM_SPEC_INT()</title>
<indexterm zone="G-PARAM-SPEC-INT--CAPS"><primary sortas="PARAM_SPEC_INT">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-INT--CAPS" role="macro">
<title>G_VALUE_HOLDS_INT()</title>
<indexterm zone="G-VALUE-HOLDS-INT--CAPS"><primary sortas="VALUE_HOLDS_INT">G_VALUE_HOLDS_INT</primary></indexterm><programlisting>#define G_VALUE_HOLDS_INT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-INT--CAPS"><literal>G_TYPE_INT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-INT--CAPS" role="macro">
<title>G_TYPE_PARAM_INT</title>
<indexterm zone="G-TYPE-PARAM-INT--CAPS"><primary sortas="TYPE_PARAM_INT">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecInt" role="struct">
<title>GParamSpecInt</title>
<indexterm zone="GParamSpecInt"><primary sortas="ParamSpecInt">GParamSpecInt</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gint          minimum;
  gint          maximum;
  gint          default_value;
} GParamSpecInt;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for integer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint">gint</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint">gint</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-int" role="function">
<title>g_param_spec_int ()</title>
<indexterm zone="g-param-spec-int"><primary sortas="param_spec_int">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 <link linkend="G-TYPE-INT--CAPS"><literal>G_TYPE_INT</literal></link> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-int" role="function">
<title>g_value_set_int ()</title>
<indexterm zone="g-value-set-int"><primary sortas="value_set_int">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 <link linkend="G-TYPE-INT--CAPS"><literal>G_TYPE_INT</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_int</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-INT--CAPS"><literal>G_TYPE_INT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_int</parameter>&#160;:</term>
<listitem><simpara> integer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-int" role="function">
<title>g_value_get_int ()</title>
<indexterm zone="g-value-get-int"><primary sortas="value_get_int">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 <link linkend="G-TYPE-INT--CAPS"><literal>G_TYPE_INT</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-INT--CAPS"><literal>G_TYPE_INT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> integer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-UINT--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_UINT()</title>
<indexterm zone="G-IS-PARAM-SPEC-UINT--CAPS"><primary sortas="IS_PARAM_SPEC_UINT">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-UINT--CAPS"><literal>G_TYPE_PARAM_UINT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-UINT--CAPS" role="macro">
<title>G_PARAM_SPEC_UINT()</title>
<indexterm zone="G-PARAM-SPEC-UINT--CAPS"><primary sortas="PARAM_SPEC_UINT">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-UINT--CAPS" role="macro">
<title>G_VALUE_HOLDS_UINT()</title>
<indexterm zone="G-VALUE-HOLDS-UINT--CAPS"><primary sortas="VALUE_HOLDS_UINT">G_VALUE_HOLDS_UINT</primary></indexterm><programlisting>#define G_VALUE_HOLDS_UINT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-UINT--CAPS" role="macro">
<title>G_TYPE_PARAM_UINT</title>
<indexterm zone="G-TYPE-PARAM-UINT--CAPS"><primary sortas="TYPE_PARAM_UINT">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecUInt" role="struct">
<title>GParamSpecUInt</title>
<indexterm zone="GParamSpecUInt"><primary sortas="ParamSpecUInt">GParamSpecUInt</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  guint         minimum;
  guint         maximum;
  guint         default_value;
} GParamSpecUInt;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned integer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-uint" role="function">
<title>g_param_spec_uint ()</title>
<indexterm zone="g-param-spec-uint"><primary sortas="param_spec_uint">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 <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-uint" role="function">
<title>g_value_set_uint ()</title>
<indexterm zone="g-value-set-uint"><primary sortas="value_set_uint">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 <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_uint</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_uint</parameter>&#160;:</term>
<listitem><simpara> unsigned integer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-uint" role="function">
<title>g_value_get_uint ()</title>
<indexterm zone="g-value-get-uint"><primary sortas="value_get_uint">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 <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> unsigned integer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-LONG--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_LONG()</title>
<indexterm zone="G-IS-PARAM-SPEC-LONG--CAPS"><primary sortas="IS_PARAM_SPEC_LONG">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-LONG--CAPS"><literal>G_TYPE_PARAM_LONG</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-LONG--CAPS" role="macro">
<title>G_PARAM_SPEC_LONG()</title>
<indexterm zone="G-PARAM-SPEC-LONG--CAPS"><primary sortas="PARAM_SPEC_LONG">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-LONG--CAPS" role="macro">
<title>G_VALUE_HOLDS_LONG()</title>
<indexterm zone="G-VALUE-HOLDS-LONG--CAPS"><primary sortas="VALUE_HOLDS_LONG">G_VALUE_HOLDS_LONG</primary></indexterm><programlisting>#define G_VALUE_HOLDS_LONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_LONG))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-LONG--CAPS"><literal>G_TYPE_LONG</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-LONG--CAPS" role="macro">
<title>G_TYPE_PARAM_LONG</title>
<indexterm zone="G-TYPE-PARAM-LONG--CAPS"><primary sortas="TYPE_PARAM_LONG">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecLong" role="struct">
<title>GParamSpecLong</title>
<indexterm zone="GParamSpecLong"><primary sortas="ParamSpecLong">GParamSpecLong</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  glong         minimum;
  glong         maximum;
  glong         default_value;
} GParamSpecLong;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for long integer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="glong">glong</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="glong">glong</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-long" role="function">
<title>g_param_spec_long ()</title>
<indexterm zone="g-param-spec-long"><primary sortas="param_spec_long">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 <link linkend="G-TYPE-LONG--CAPS"><literal>G_TYPE_LONG</literal></link> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-long" role="function">
<title>g_value_set_long ()</title>
<indexterm zone="g-value-set-long"><primary sortas="value_set_long">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 <link linkend="G-TYPE-LONG--CAPS"><literal>G_TYPE_LONG</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_long</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-LONG--CAPS"><literal>G_TYPE_LONG</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_long</parameter>&#160;:</term>
<listitem><simpara> long integer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-long" role="function">
<title>g_value_get_long ()</title>
<indexterm zone="g-value-get-long"><primary sortas="value_get_long">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 <link linkend="G-TYPE-LONG--CAPS"><literal>G_TYPE_LONG</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-LONG--CAPS"><literal>G_TYPE_LONG</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> long integer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-ULONG--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_ULONG()</title>
<indexterm zone="G-IS-PARAM-SPEC-ULONG--CAPS"><primary sortas="IS_PARAM_SPEC_ULONG">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-ULONG--CAPS"><literal>G_TYPE_PARAM_ULONG</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-ULONG--CAPS" role="macro">
<title>G_PARAM_SPEC_ULONG()</title>
<indexterm zone="G-PARAM-SPEC-ULONG--CAPS"><primary sortas="PARAM_SPEC_ULONG">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-ULONG--CAPS" role="macro">
<title>G_VALUE_HOLDS_ULONG()</title>
<indexterm zone="G-VALUE-HOLDS-ULONG--CAPS"><primary sortas="VALUE_HOLDS_ULONG">G_VALUE_HOLDS_ULONG</primary></indexterm><programlisting>#define G_VALUE_HOLDS_ULONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ULONG))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-ULONG--CAPS"><literal>G_TYPE_ULONG</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-ULONG--CAPS" role="macro">
<title>G_TYPE_PARAM_ULONG</title>
<indexterm zone="G-TYPE-PARAM-ULONG--CAPS"><primary sortas="TYPE_PARAM_ULONG">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecULong" role="struct">
<title>GParamSpecULong</title>
<indexterm zone="GParamSpecULong"><primary sortas="ParamSpecULong">GParamSpecULong</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gulong        minimum;
  gulong        maximum;
  gulong        default_value;
} GParamSpecULong;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned long integer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gulong">gulong</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gulong">gulong</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-ulong" role="function">
<title>g_param_spec_ulong ()</title>
<indexterm zone="g-param-spec-ulong"><primary sortas="param_spec_ulong">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 <link linkend="G-TYPE-ULONG--CAPS"><literal>G_TYPE_ULONG</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-ulong" role="function">
<title>g_value_set_ulong ()</title>
<indexterm zone="g-value-set-ulong"><primary sortas="value_set_ulong">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 <link linkend="G-TYPE-ULONG--CAPS"><literal>G_TYPE_ULONG</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_ulong</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-ULONG--CAPS"><literal>G_TYPE_ULONG</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_ulong</parameter>&#160;:</term>
<listitem><simpara> unsigned long integer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-ulong" role="function">
<title>g_value_get_ulong ()</title>
<indexterm zone="g-value-get-ulong"><primary sortas="value_get_ulong">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 <link linkend="G-TYPE-ULONG--CAPS"><literal>G_TYPE_ULONG</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-ULONG--CAPS"><literal>G_TYPE_ULONG</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> unsigned long integer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-INT64--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_INT64()</title>
<indexterm zone="G-IS-PARAM-SPEC-INT64--CAPS"><primary sortas="IS_PARAM_SPEC_INT64">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-INT64--CAPS"><literal>G_TYPE_PARAM_INT64</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-INT64--CAPS" role="macro">
<title>G_PARAM_SPEC_INT64()</title>
<indexterm zone="G-PARAM-SPEC-INT64--CAPS"><primary sortas="PARAM_SPEC_INT64">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-INT64--CAPS" role="macro">
<title>G_VALUE_HOLDS_INT64()</title>
<indexterm zone="G-VALUE-HOLDS-INT64--CAPS"><primary sortas="VALUE_HOLDS_INT64">G_VALUE_HOLDS_INT64</primary></indexterm><programlisting>#define G_VALUE_HOLDS_INT64(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT64))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-INT64--CAPS"><literal>G_TYPE_INT64</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-INT64--CAPS" role="macro">
<title>G_TYPE_PARAM_INT64</title>
<indexterm zone="G-TYPE-PARAM-INT64--CAPS"><primary sortas="TYPE_PARAM_INT64">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecInt64" role="struct">
<title>GParamSpecInt64</title>
<indexterm zone="GParamSpecInt64"><primary sortas="ParamSpecInt64">GParamSpecInt64</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gint64        minimum;
  gint64        maximum;
  gint64        default_value;
} GParamSpecInt64;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for 64bit integer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint64">gint64</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gint64">gint64</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-int64" role="function">
<title>g_param_spec_int64 ()</title>
<indexterm zone="g-param-spec-int64"><primary sortas="param_spec_int64">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 <link linkend="G-TYPE-INT64--CAPS"><literal>G_TYPE_INT64</literal></link> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-int64" role="function">
<title>g_value_set_int64 ()</title>
<indexterm zone="g-value-set-int64"><primary sortas="value_set_int64">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 <link linkend="G-TYPE-INT64--CAPS"><literal>G_TYPE_INT64</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_int64</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-INT64--CAPS"><literal>G_TYPE_INT64</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_int64</parameter>&#160;:</term>
<listitem><simpara> 64bit integer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-int64" role="function">
<title>g_value_get_int64 ()</title>
<indexterm zone="g-value-get-int64"><primary sortas="value_get_int64">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 <link linkend="G-TYPE-INT64--CAPS"><literal>G_TYPE_INT64</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-INT64--CAPS"><literal>G_TYPE_INT64</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> 64bit integer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-UINT64--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_UINT64()</title>
<indexterm zone="G-IS-PARAM-SPEC-UINT64--CAPS"><primary sortas="IS_PARAM_SPEC_UINT64">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-UINT64--CAPS"><literal>G_TYPE_PARAM_UINT64</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-UINT64--CAPS" role="macro">
<title>G_PARAM_SPEC_UINT64()</title>
<indexterm zone="G-PARAM-SPEC-UINT64--CAPS"><primary sortas="PARAM_SPEC_UINT64">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-UINT64--CAPS" role="macro">
<title>G_VALUE_HOLDS_UINT64()</title>
<indexterm zone="G-VALUE-HOLDS-UINT64--CAPS"><primary sortas="VALUE_HOLDS_UINT64">G_VALUE_HOLDS_UINT64</primary></indexterm><programlisting>#define G_VALUE_HOLDS_UINT64(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT64))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-UINT64--CAPS"><literal>G_TYPE_UINT64</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-UINT64--CAPS" role="macro">
<title>G_TYPE_PARAM_UINT64</title>
<indexterm zone="G-TYPE-PARAM-UINT64--CAPS"><primary sortas="TYPE_PARAM_UINT64">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecUInt64" role="struct">
<title>GParamSpecUInt64</title>
<indexterm zone="GParamSpecUInt64"><primary sortas="ParamSpecUInt64">GParamSpecUInt64</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  guint64       minimum;
  guint64       maximum;
  guint64       default_value;
} GParamSpecUInt64;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unsigned 64bit integer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint64">guint64</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint64">guint64</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-uint64" role="function">
<title>g_param_spec_uint64 ()</title>
<indexterm zone="g-param-spec-uint64"><primary sortas="param_spec_uint64">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 <link linkend="G-TYPE-UINT64--CAPS"><literal>G_TYPE_UINT64</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-uint64" role="function">
<title>g_value_set_uint64 ()</title>
<indexterm zone="g-value-set-uint64"><primary sortas="value_set_uint64">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 <link linkend="G-TYPE-UINT64--CAPS"><literal>G_TYPE_UINT64</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_uint64</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-UINT64--CAPS"><literal>G_TYPE_UINT64</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_uint64</parameter>&#160;:</term>
<listitem><simpara> unsigned 64bit integer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-uint64" role="function">
<title>g_value_get_uint64 ()</title>
<indexterm zone="g-value-get-uint64"><primary sortas="value_get_uint64">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 <link linkend="G-TYPE-UINT64--CAPS"><literal>G_TYPE_UINT64</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-UINT64--CAPS"><literal>G_TYPE_UINT64</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> unsigned 64bit integer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-FLOAT--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_FLOAT()</title>
<indexterm zone="G-IS-PARAM-SPEC-FLOAT--CAPS"><primary sortas="IS_PARAM_SPEC_FLOAT">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-FLOAT--CAPS"><literal>G_TYPE_PARAM_FLOAT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-FLOAT--CAPS" role="macro">
<title>G_PARAM_SPEC_FLOAT()</title>
<indexterm zone="G-PARAM-SPEC-FLOAT--CAPS"><primary sortas="PARAM_SPEC_FLOAT">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-FLOAT--CAPS" role="macro">
<title>G_VALUE_HOLDS_FLOAT()</title>
<indexterm zone="G-VALUE-HOLDS-FLOAT--CAPS"><primary sortas="VALUE_HOLDS_FLOAT">G_VALUE_HOLDS_FLOAT</primary></indexterm><programlisting>#define G_VALUE_HOLDS_FLOAT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLOAT))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-FLOAT--CAPS"><literal>G_TYPE_FLOAT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-FLOAT--CAPS" role="macro">
<title>G_TYPE_PARAM_FLOAT</title>
<indexterm zone="G-TYPE-PARAM-FLOAT--CAPS"><primary sortas="TYPE_PARAM_FLOAT">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecFloat" role="struct">
<title>GParamSpecFloat</title>
<indexterm zone="GParamSpecFloat"><primary sortas="ParamSpecFloat">GParamSpecFloat</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gfloat        minimum;
  gfloat        maximum;
  gfloat        default_value;
  gfloat        epsilon;
} GParamSpecFloat;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for float properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gfloat">gfloat</link>&#160;<structfield>epsilon</structfield>;</term>
<listitem><simpara> values closer than <parameter>epsilon</parameter> will be considered identical
 by <link linkend="g-param-values-cmp"><function>g_param_values_cmp()</function></link>; the default value is 1e-30.
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-float" role="function">
<title>g_param_spec_float ()</title>
<indexterm zone="g-param-spec-float"><primary sortas="param_spec_float">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 <link linkend="G-TYPE-FLOAT--CAPS"><literal>G_TYPE_FLOAT</literal></link> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-float" role="function">
<title>g_value_set_float ()</title>
<indexterm zone="g-value-set-float"><primary sortas="value_set_float">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 <link linkend="G-TYPE-FLOAT--CAPS"><literal>G_TYPE_FLOAT</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_float</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-FLOAT--CAPS"><literal>G_TYPE_FLOAT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_float</parameter>&#160;:</term>
<listitem><simpara> float value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-float" role="function">
<title>g_value_get_float ()</title>
<indexterm zone="g-value-get-float"><primary sortas="value_get_float">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 <link linkend="G-TYPE-FLOAT--CAPS"><literal>G_TYPE_FLOAT</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-FLOAT--CAPS"><literal>G_TYPE_FLOAT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> float contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-DOUBLE--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_DOUBLE()</title>
<indexterm zone="G-IS-PARAM-SPEC-DOUBLE--CAPS"><primary sortas="IS_PARAM_SPEC_DOUBLE">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-DOUBLE--CAPS"><literal>G_TYPE_PARAM_DOUBLE</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-DOUBLE--CAPS" role="macro">
<title>G_PARAM_SPEC_DOUBLE()</title>
<indexterm zone="G-PARAM-SPEC-DOUBLE--CAPS"><primary sortas="PARAM_SPEC_DOUBLE">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-DOUBLE--CAPS" role="macro">
<title>G_VALUE_HOLDS_DOUBLE()</title>
<indexterm zone="G-VALUE-HOLDS-DOUBLE--CAPS"><primary sortas="VALUE_HOLDS_DOUBLE">G_VALUE_HOLDS_DOUBLE</primary></indexterm><programlisting>#define G_VALUE_HOLDS_DOUBLE(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_DOUBLE))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-DOUBLE--CAPS"><literal>G_TYPE_DOUBLE</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-DOUBLE--CAPS" role="macro">
<title>G_TYPE_PARAM_DOUBLE</title>
<indexterm zone="G-TYPE-PARAM-DOUBLE--CAPS"><primary sortas="TYPE_PARAM_DOUBLE">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecDouble" role="struct">
<title>GParamSpecDouble</title>
<indexterm zone="GParamSpecDouble"><primary sortas="ParamSpecDouble">GParamSpecDouble</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gdouble       minimum;
  gdouble       maximum;
  gdouble       default_value;
  gdouble       epsilon;
} GParamSpecDouble;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for double properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>minimum</structfield>;</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link>&#160;<structfield>maximum</structfield>;</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gdouble">gdouble</link>&#160;<structfield>epsilon</structfield>;</term>
<listitem><simpara> values closer than <parameter>epsilon</parameter> will be considered identical
 by <link linkend="g-param-values-cmp"><function>g_param_values_cmp()</function></link>; the default value is 1e-90.
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-double" role="function">
<title>g_param_spec_double ()</title>
<indexterm zone="g-param-spec-double"><primary sortas="param_spec_double">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 <link linkend="G-TYPE-DOUBLE--CAPS"><literal>G_TYPE_DOUBLE</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>minimum</parameter>&#160;:</term>
<listitem><simpara> minimum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>maximum</parameter>&#160;:</term>
<listitem><simpara> maximum value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-double" role="function">
<title>g_value_set_double ()</title>
<indexterm zone="g-value-set-double"><primary sortas="value_set_double">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 <link linkend="G-TYPE-DOUBLE--CAPS"><literal>G_TYPE_DOUBLE</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_double</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-DOUBLE--CAPS"><literal>G_TYPE_DOUBLE</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_double</parameter>&#160;:</term>
<listitem><simpara> double value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-double" role="function">
<title>g_value_get_double ()</title>
<indexterm zone="g-value-get-double"><primary sortas="value_get_double">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 <link linkend="G-TYPE-DOUBLE--CAPS"><literal>G_TYPE_DOUBLE</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-DOUBLE--CAPS"><literal>G_TYPE_DOUBLE</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> double contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-ENUM--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_ENUM()</title>
<indexterm zone="G-IS-PARAM-SPEC-ENUM--CAPS"><primary sortas="IS_PARAM_SPEC_ENUM">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-ENUM--CAPS"><literal>G_TYPE_PARAM_ENUM</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-ENUM--CAPS" role="macro">
<title>G_PARAM_SPEC_ENUM()</title>
<indexterm zone="G-PARAM-SPEC-ENUM--CAPS"><primary sortas="PARAM_SPEC_ENUM">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-ENUM--CAPS" role="macro">
<title>G_VALUE_HOLDS_ENUM()</title>
<indexterm zone="G-VALUE-HOLDS-ENUM--CAPS"><primary sortas="VALUE_HOLDS_ENUM">G_VALUE_HOLDS_ENUM</primary></indexterm><programlisting>#define G_VALUE_HOLDS_ENUM(value)      (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ENUM))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-ENUM--CAPS" role="macro">
<title>G_TYPE_PARAM_ENUM</title>
<indexterm zone="G-TYPE-PARAM-ENUM--CAPS"><primary sortas="TYPE_PARAM_ENUM">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecEnum" role="struct">
<title>GParamSpecEnum</title>
<indexterm zone="GParamSpecEnum"><primary sortas="ParamSpecEnum">GParamSpecEnum</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  GEnumClass   *enum_class;
  gint          default_value;
} GParamSpecEnum;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for enum 
properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;*<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>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-enum" role="function">
<title>g_param_spec_enum ()</title>
<indexterm zone="g-param-spec-enum"><primary sortas="param_spec_enum">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 <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>enum_type</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GType"><type>GType</type></link> derived from <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-enum" role="function">
<title>g_value_set_enum ()</title>
<indexterm zone="g-value-set-enum"><primary sortas="value_set_enum">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 <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_enum</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_enum</parameter>&#160;:</term>
<listitem><simpara> enum value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-enum" role="function">
<title>g_value_get_enum ()</title>
<indexterm zone="g-value-get-enum"><primary sortas="value_get_enum">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 <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-ENUM--CAPS"><literal>G_TYPE_ENUM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> enum contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-FLAGS--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_FLAGS()</title>
<indexterm zone="G-IS-PARAM-SPEC-FLAGS--CAPS"><primary sortas="IS_PARAM_SPEC_FLAGS">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-FLAGS--CAPS"><literal>G_TYPE_PARAM_FLAGS</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-FLAGS--CAPS" role="macro">
<title>G_PARAM_SPEC_FLAGS()</title>
<indexterm zone="G-PARAM-SPEC-FLAGS--CAPS"><primary sortas="PARAM_SPEC_FLAGS">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-FLAGS--CAPS" role="macro">
<title>G_VALUE_HOLDS_FLAGS()</title>
<indexterm zone="G-VALUE-HOLDS-FLAGS--CAPS"><primary sortas="VALUE_HOLDS_FLAGS">G_VALUE_HOLDS_FLAGS</primary></indexterm><programlisting>#define G_VALUE_HOLDS_FLAGS(value)     (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLAGS))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-FLAGS--CAPS" role="macro">
<title>G_TYPE_PARAM_FLAGS</title>
<indexterm zone="G-TYPE-PARAM-FLAGS--CAPS"><primary sortas="TYPE_PARAM_FLAGS">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecFlags" role="struct">
<title>GParamSpecFlags</title>
<indexterm zone="GParamSpecFlags"><primary sortas="ParamSpecFlags">GParamSpecFlags</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  GFlagsClass  *flags_class;
  guint         default_value;
} GParamSpecFlags;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for flags
properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;*<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>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-flags" role="function">
<title>g_param_spec_flags ()</title>
<indexterm zone="g-param-spec-flags"><primary sortas="param_spec_flags">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="GParamSpecFlags"><type>GParamSpecFlags</type></link> instance specifying a <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags_type</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GType"><type>GType</type></link> derived from <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-flags" role="function">
<title>g_value_set_flags ()</title>
<indexterm zone="g-value-set-flags"><primary sortas="value_set_flags">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 <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_flags</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_flags</parameter>&#160;:</term>
<listitem><simpara> flags value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-flags" role="function">
<title>g_value_get_flags ()</title>
<indexterm zone="g-value-get-flags"><primary sortas="value_get_flags">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 <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-FLAGS--CAPS"><literal>G_TYPE_FLAGS</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> flags contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-STRING--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_STRING()</title>
<indexterm zone="G-IS-PARAM-SPEC-STRING--CAPS"><primary sortas="IS_PARAM_SPEC_STRING">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-STRING--CAPS"><literal>G_TYPE_PARAM_STRING</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-STRING--CAPS" role="macro">
<title>G_PARAM_SPEC_STRING()</title>
<indexterm zone="G-PARAM-SPEC-STRING--CAPS"><primary sortas="PARAM_SPEC_STRING">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-STRING--CAPS" role="macro">
<title>G_VALUE_HOLDS_STRING()</title>
<indexterm zone="G-VALUE-HOLDS-STRING--CAPS"><primary sortas="VALUE_HOLDS_STRING">G_VALUE_HOLDS_STRING</primary></indexterm><programlisting>#define G_VALUE_HOLDS_STRING(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_STRING))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-STRING--CAPS" role="macro">
<title>G_TYPE_PARAM_STRING</title>
<indexterm zone="G-TYPE-PARAM-STRING--CAPS"><primary sortas="TYPE_PARAM_STRING">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecString" role="struct">
<title>GParamSpecString</title>
<indexterm zone="GParamSpecString"><primary sortas="ParamSpecString">GParamSpecString</primary></indexterm><programlisting>typedef struct {
  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;
} GParamSpecString;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for string
properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;*<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="gchar">gchar</link>&#160;*<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>&#160;*<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>&#160;<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>&#160;<structfield>null_fold_if_empty</structfield>&#160;:&#160;1;</term>
<listitem><simpara> replace empty string by <link linkend="NULL--CAPS"><literal>NULL</literal></link>
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link>&#160;<structfield>ensure_non_null</structfield>&#160;:&#160;1;</term>
<listitem><simpara> replace <link linkend="NULL--CAPS"><literal>NULL</literal></link> strings by an empty string
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="gchararray" role="typedef">
<title>gchararray</title>
<indexterm zone="gchararray"><primary sortas="chararray">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>
<para>
</para></refsect2>
<refsect2 id="g-param-spec-string" role="function">
<title>g_param_spec_string ()</title>
<indexterm zone="g-param-spec-string"><primary sortas="param_spec_string">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-string" role="function">
<title>g_value_set_string ()</title>
<indexterm zone="g-value-set-string"><primary sortas="value_set_string">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 <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_string</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&#160;:</term>
<listitem><simpara> caller-owned string to be duplicated for the <link linkend="GValue"><type>GValue</type></link>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-static-string" role="function">
<title>g_value_set_static_string ()</title>
<indexterm zone="g-value-set-static-string"><primary sortas="value_set_static_string">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 <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link> <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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&#160;:</term>
<listitem><simpara> static string to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-take-string" role="function" condition="since:2.4">
<title>g_value_take_string ()</title>
<indexterm zone="g-value-take-string" role="2.4"><primary sortas="value_take_string">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 <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_string</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&#160;:</term>
<listitem><simpara> string to take ownership of
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="g-value-set-string-take-ownership" role="function" condition="deprecated:2.4: Use g_value_take_string() instead.">
<title>g_value_set_string_take_ownership ()</title>
<indexterm zone="g-value-set-string-take-ownership" role="deprecated"><primary sortas="value_set_string_take_ownership">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> has been deprecated since version 2.4 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_string</parameter>&#160;:</term>
<listitem><simpara> duplicated unowned string to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-string" role="function">
<title>g_value_get_string ()</title>
<indexterm zone="g-value-get-string"><primary sortas="value_get_string">g_value_get_string</primary></indexterm><programlisting>const <link linkend="gchar">gchar</link>*        g_value_get_string                  (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> string content of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-dup-string" role="function">
<title>g_value_dup_string ()</title>
<indexterm zone="g-value-dup-string"><primary sortas="value_dup_string">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 <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-STRING--CAPS"><literal>G_TYPE_STRING</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly allocated copy of the string content of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-PARAM--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_PARAM()</title>
<indexterm zone="G-IS-PARAM-SPEC-PARAM--CAPS"><primary sortas="IS_PARAM_SPEC_PARAM">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-PARAM--CAPS"><literal>G_TYPE_PARAM_PARAM</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-PARAM--CAPS" role="macro">
<title>G_PARAM_SPEC_PARAM()</title>
<indexterm zone="G-PARAM-SPEC-PARAM--CAPS"><primary sortas="PARAM_SPEC_PARAM">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-PARAM--CAPS" role="macro">
<title>G_VALUE_HOLDS_PARAM()</title>
<indexterm zone="G-VALUE-HOLDS-PARAM--CAPS"><primary sortas="VALUE_HOLDS_PARAM">G_VALUE_HOLDS_PARAM</primary></indexterm><programlisting>#define G_VALUE_HOLDS_PARAM(value)	(G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_PARAM))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-PARAM--CAPS" role="macro">
<title>G_TYPE_PARAM_PARAM</title>
<indexterm zone="G-TYPE-PARAM-PARAM--CAPS"><primary sortas="TYPE_PARAM_PARAM">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecParam" role="struct">
<title>GParamSpecParam</title>
<indexterm zone="GParamSpecParam"><primary sortas="ParamSpecParam">GParamSpecParam</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
} GParamSpecParam;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<structfield>parent_instance</structfield>;</term>
<listitem><simpara> private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-param" role="function">
<title>g_param_spec_param ()</title>
<indexterm zone="g-param-spec-param"><primary sortas="param_spec_param">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 <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param_type</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GType"><type>GType</type></link> derived from <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-param" role="function">
<title>g_value_set_param ()</title>
<indexterm zone="g-value-set-param"><primary sortas="value_set_param">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 <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>param</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param</parameter>&#160;:</term>
<listitem><simpara> the <link linkend="GParamSpec"><type>GParamSpec</type></link> to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-take-param" role="function" condition="since:2.4">
<title>g_value_take_param ()</title>
<indexterm zone="g-value-take-param" role="2.4"><primary sortas="value_take_param">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 <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link> <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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param</parameter>&#160;:</term>
<listitem><simpara> the <link linkend="GParamSpec"><type>GParamSpec</type></link> to be set
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="g-value-set-param-take-ownership" role="function" condition="deprecated:2.4: Use g_value_take_param() instead.">
<title>g_value_set_param_take_ownership ()</title>
<indexterm zone="g-value-set-param-take-ownership" role="deprecated"><primary sortas="value_set_param_take_ownership">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> has been deprecated since version 2.4 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>param</parameter>&#160;:</term>
<listitem><simpara> the <link linkend="GParamSpec"><type>GParamSpec</type></link> to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-param" role="function">
<title>g_value_get_param ()</title>
<indexterm zone="g-value-get-param"><primary sortas="value_get_param">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 <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> <link linkend="GParamSpec"><type>GParamSpec</type></link> content of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-dup-param" role="function">
<title>g_value_dup_param ()</title>
<indexterm zone="g-value-dup-param"><primary sortas="value_dup_param">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 <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link> <link linkend="GValue"><type>GValue</type></link>, increasing its
reference count.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-PARAM--CAPS"><literal>G_TYPE_PARAM</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</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 id="G-IS-PARAM-SPEC-BOXED--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_BOXED()</title>
<indexterm zone="G-IS-PARAM-SPEC-BOXED--CAPS"><primary sortas="IS_PARAM_SPEC_BOXED">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-BOXED--CAPS"><literal>G_TYPE_PARAM_BOXED</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-BOXED--CAPS" role="macro">
<title>G_PARAM_SPEC_BOXED()</title>
<indexterm zone="G-PARAM-SPEC-BOXED--CAPS"><primary sortas="PARAM_SPEC_BOXED">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-BOXED--CAPS" role="macro">
<title>G_VALUE_HOLDS_BOXED()</title>
<indexterm zone="G-VALUE-HOLDS-BOXED--CAPS"><primary sortas="VALUE_HOLDS_BOXED">G_VALUE_HOLDS_BOXED</primary></indexterm><programlisting>#define G_VALUE_HOLDS_BOXED(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOXED))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-BOXED--CAPS" role="macro">
<title>G_TYPE_PARAM_BOXED</title>
<indexterm zone="G-TYPE-PARAM-BOXED--CAPS"><primary sortas="TYPE_PARAM_BOXED">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecBoxed" role="struct">
<title>GParamSpecBoxed</title>
<indexterm zone="GParamSpecBoxed"><primary sortas="ParamSpecBoxed">GParamSpecBoxed</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
} GParamSpecBoxed;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for boxed properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<structfield>parent_instance</structfield>;</term>
<listitem><simpara> private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-boxed" role="function">
<title>g_param_spec_boxed ()</title>
<indexterm zone="g-param-spec-boxed"><primary sortas="param_spec_boxed">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 <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link>
derived property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>boxed_type</parameter>&#160;:</term>
<listitem><simpara> <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type of this property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-boxed" role="function">
<title>g_value_set_boxed ()</title>
<indexterm zone="g-value-set-boxed"><primary sortas="value_set_boxed">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 <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived <link linkend="GValue"><type>GValue</type></link> to <parameter>v_boxed</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&#160;:</term>
<listitem><simpara> boxed value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-static-boxed" role="function">
<title>g_value_set_static_boxed ()</title>
<indexterm zone="g-value-set-static-boxed"><primary sortas="value_set_static_boxed">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 <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&#160;:</term>
<listitem><simpara> static boxed value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-take-boxed" role="function" condition="since:2.4">
<title>g_value_take_boxed ()</title>
<indexterm zone="g-value-take-boxed" role="2.4"><primary sortas="value_take_boxed">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 <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&#160;:</term>
<listitem><simpara> duplicated unowned boxed value to be set
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="g-value-set-boxed-take-ownership" role="function" condition="deprecated:2.4: Use g_value_take_boxed() instead.">
<title>g_value_set_boxed_take_ownership ()</title>
<indexterm zone="g-value-set-boxed-take-ownership" role="deprecated"><primary sortas="value_set_boxed_take_ownership">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> has been deprecated since version 2.4 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_boxed</parameter>&#160;:</term>
<listitem><simpara> duplicated unowned boxed value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-boxed" role="function">
<title>g_value_get_boxed ()</title>
<indexterm zone="g-value-get-boxed"><primary sortas="value_get_boxed">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 <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> boxed contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-dup-boxed" role="function">
<title>g_value_dup_boxed ()</title>
<indexterm zone="g-value-dup-boxed"><primary sortas="value_dup_boxed">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 <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> boxed contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-POINTER--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_POINTER()</title>
<indexterm zone="G-IS-PARAM-SPEC-POINTER--CAPS"><primary sortas="IS_PARAM_SPEC_POINTER">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-POINTER--CAPS"><literal>G_TYPE_PARAM_POINTER</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-POINTER--CAPS" role="macro">
<title>G_PARAM_SPEC_POINTER()</title>
<indexterm zone="G-PARAM-SPEC-POINTER--CAPS"><primary sortas="PARAM_SPEC_POINTER">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-POINTER--CAPS" role="macro">
<title>G_VALUE_HOLDS_POINTER()</title>
<indexterm zone="G-VALUE-HOLDS-POINTER--CAPS"><primary sortas="VALUE_HOLDS_POINTER">G_VALUE_HOLDS_POINTER</primary></indexterm><programlisting>#define G_VALUE_HOLDS_POINTER(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_POINTER))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-POINTER--CAPS"><literal>G_TYPE_POINTER</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-POINTER--CAPS" role="macro">
<title>G_TYPE_PARAM_POINTER</title>
<indexterm zone="G-TYPE-PARAM-POINTER--CAPS"><primary sortas="TYPE_PARAM_POINTER">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecPointer" role="struct">
<title>GParamSpecPointer</title>
<indexterm zone="GParamSpecPointer"><primary sortas="ParamSpecPointer">GParamSpecPointer</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
} GParamSpecPointer;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for pointer properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<structfield>parent_instance</structfield>;</term>
<listitem><simpara> private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-pointer" role="function">
<title>g_param_spec_pointer ()</title>
<indexterm zone="g-param-spec-pointer"><primary sortas="param_spec_pointer">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-pointer" role="function">
<title>g_value_set_pointer ()</title>
<indexterm zone="g-value-set-pointer"><primary sortas="value_set_pointer">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-POINTER--CAPS"><literal>G_TYPE_POINTER</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_pointer</parameter>&#160;:</term>
<listitem><simpara> pointer value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-pointer" role="function">
<title>g_value_get_pointer ()</title>
<indexterm zone="g-value-get-pointer"><primary sortas="value_get_pointer">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-POINTER--CAPS"><literal>G_TYPE_POINTER</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> pointer contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-OBJECT--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_OBJECT()</title>
<indexterm zone="G-IS-PARAM-SPEC-OBJECT--CAPS"><primary sortas="IS_PARAM_SPEC_OBJECT">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-OBJECT--CAPS"><literal>G_TYPE_PARAM_OBJECT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-OBJECT--CAPS" role="macro">
<title>G_PARAM_SPEC_OBJECT()</title>
<indexterm zone="G-PARAM-SPEC-OBJECT--CAPS"><primary sortas="PARAM_SPEC_OBJECT">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-VALUE-HOLDS-OBJECT--CAPS" role="macro">
<title>G_VALUE_HOLDS_OBJECT()</title>
<indexterm zone="G-VALUE-HOLDS-OBJECT--CAPS"><primary sortas="VALUE_HOLDS_OBJECT">G_VALUE_HOLDS_OBJECT</primary></indexterm><programlisting>#define G_VALUE_HOLDS_OBJECT(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_OBJECT))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values derived from type <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-OBJECT--CAPS" role="macro">
<title>G_TYPE_PARAM_OBJECT</title>
<indexterm zone="G-TYPE-PARAM-OBJECT--CAPS"><primary sortas="TYPE_PARAM_OBJECT">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecObject" role="struct">
<title>GParamSpecObject</title>
<indexterm zone="GParamSpecObject"><primary sortas="ParamSpecObject">GParamSpecObject</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
} GParamSpecObject;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for object properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<structfield>parent_instance</structfield>;</term>
<listitem><simpara> private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-object" role="function">
<title>g_param_spec_object ()</title>
<indexterm zone="g-param-spec-object"><primary sortas="param_spec_object">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 <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link>
derived property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>object_type</parameter>&#160;:</term>
<listitem><simpara> <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived type of this property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-set-object" role="function">
<title>g_value_set_object ()</title>
<indexterm zone="g-value-set-object"><primary sortas="value_set_object">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 <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived <link linkend="GValue"><type>GValue</type></link> to <parameter>v_object</parameter>.
</para>
<para>
<link linkend="g-value-set-object"><function>g_value_set_object()</function></link> increases the reference count of <parameter>v_object</parameter>
(the <link linkend="GValue"><type>GValue</type></link> holds a reference to <parameter>v_object</parameter>).  If you do not wish
to increase the reference count of the object (i.e. you wish to
pass your current reference to the <link linkend="GValue"><type>GValue</type></link> because you no longer
need it), use <link linkend="g-value-take-object"><function>g_value_take_object()</function></link> instead.
</para>
<para>
It is important that your <link linkend="GValue"><type>GValue</type></link> holds a reference to <parameter>v_object</parameter> (either its
own, or one it has taken) to ensure that the object won't be destroyed while
the <link linkend="GValue"><type>GValue</type></link> still exists).</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_object</parameter>&#160;:</term>
<listitem><simpara> object value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-take-object" role="function" condition="since:2.4">
<title>g_value_take_object ()</title>
<indexterm zone="g-value-take-object" role="2.4"><primary sortas="value_take_object">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 <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> 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 (i.e. the reference
count of the object is not increased).
</para>
<para>
If you want the <link linkend="GValue"><type>GValue</type></link> to hold its own reference to <parameter>v_object</parameter>, use
<link linkend="g-value-set-object"><function>g_value_set_object()</function></link> instead.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_object</parameter>&#160;:</term>
<listitem><simpara> object value to be set
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="g-value-set-object-take-ownership" role="function" condition="deprecated:2.4: Use g_value_take_object() instead.">
<title>g_value_set_object_take_ownership ()</title>
<indexterm zone="g-value-set-object-take-ownership" role="deprecated"><primary sortas="value_set_object_take_ownership">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> has been deprecated since version 2.4 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_object</parameter>&#160;:</term>
<listitem><simpara> object value to be set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-get-object" role="function">
<title>g_value_get_object ()</title>
<indexterm zone="g-value-get-object"><primary sortas="value_get_object">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 <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived type
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> object contents of <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="g-value-dup-object" role="function">
<title>g_value_dup_object ()</title>
<indexterm zone="g-value-dup-object"><primary sortas="value_dup_object">g_value_dup_object</primary></indexterm><programlisting><link linkend="gpointer">gpointer</link>            g_value_dup_object                  (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link> derived <link linkend="GValue"><type>GValue</type></link>, increasing
its reference count.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> whose type is derived from <link linkend="G-TYPE-OBJECT--CAPS"><literal>G_TYPE_OBJECT</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> object content of <parameter>value</parameter>, should be unreferenced when no
         longer needed.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-UNICHAR--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_UNICHAR()</title>
<indexterm zone="G-IS-PARAM-SPEC-UNICHAR--CAPS"><primary sortas="IS_PARAM_SPEC_UNICHAR">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-UNICHAR--CAPS"><literal>G_TYPE_PARAM_UNICHAR</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-UNICHAR--CAPS" role="macro">
<title>G_PARAM_SPEC_UNICHAR()</title>
<indexterm zone="G-PARAM-SPEC-UNICHAR--CAPS"><primary sortas="PARAM_SPEC_UNICHAR">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-UNICHAR--CAPS" role="macro">
<title>G_TYPE_PARAM_UNICHAR</title>
<indexterm zone="G-TYPE-PARAM-UNICHAR--CAPS"><primary sortas="TYPE_PARAM_UNICHAR">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecUnichar" role="struct">
<title>GParamSpecUnichar</title>
<indexterm zone="GParamSpecUnichar"><primary sortas="ParamSpecUnichar">GParamSpecUnichar</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  
  gunichar      default_value;
} GParamSpecUnichar;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for unichar (unsigned integer) properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;<structfield>default_value</structfield>;</term>
<listitem><simpara> default value for the property specified
</simpara></listitem>
</varlistentry>
</variablelist></refsect2>
<refsect2 id="g-param-spec-unichar" role="function">
<title>g_param_spec_unichar ()</title>
<indexterm zone="g-param-spec-unichar"><primary sortas="param_spec_unichar">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 <link linkend="G-TYPE-UINT--CAPS"><literal>G_TYPE_UINT</literal></link>
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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>default_value</parameter>&#160;:</term>
<listitem><simpara> default value for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-VALUE-ARRAY--CAPS" role="macro">
<title>G_IS_PARAM_SPEC_VALUE_ARRAY()</title>
<indexterm zone="G-IS-PARAM-SPEC-VALUE-ARRAY--CAPS"><primary sortas="IS_PARAM_SPEC_VALUE_ARRAY">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-VALUE-ARRAY--CAPS"><literal>G_TYPE_PARAM_VALUE_ARRAY</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-PARAM-SPEC-VALUE-ARRAY--CAPS" role="macro">
<title>G_PARAM_SPEC_VALUE_ARRAY()</title>
<indexterm zone="G-PARAM-SPEC-VALUE-ARRAY--CAPS"><primary sortas="PARAM_SPEC_VALUE_ARRAY">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GParamSpec"><type>GParamSpec</type></link> instance
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-TYPE-PARAM-VALUE-ARRAY--CAPS" role="macro">
<title>G_TYPE_PARAM_VALUE_ARRAY</title>
<indexterm zone="G-TYPE-PARAM-VALUE-ARRAY--CAPS"><primary sortas="TYPE_PARAM_VALUE_ARRAY">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>
<para>
</para></refsect2>
<refsect2 id="GParamSpecValueArray" role="struct">
<title>GParamSpecValueArray</title>
<indexterm zone="GParamSpecValueArray"><primary sortas="ParamSpecValueArray">GParamSpecValueArray</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  GParamSpec   *element_spec;
  guint		fixed_n_elements;
} GParamSpecValueArray;
</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>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<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>&#160;*<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 <link linkend="NULL--CAPS"><literal>NULL</literal></link>
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="guint">guint</link>&#160;<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 id="g-param-spec-value-array" role="function">
<title>g_param_spec_value_array ()</title>
<indexterm zone="g-param-spec-value-array"><primary sortas="param_spec_value_array">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
<link linkend="G-TYPE-VALUE-ARRAY--CAPS"><literal>G_TYPE_VALUE_ARRAY</literal></link> property. <link linkend="G-TYPE-VALUE-ARRAY--CAPS"><literal>G_TYPE_VALUE_ARRAY</literal></link> is a
<link linkend="G-TYPE-BOXED--CAPS"><literal>G_TYPE_BOXED</literal></link> 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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>element_spec</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link> describing the elements contained in
 arrays of this property, may be <link linkend="NULL--CAPS"><literal>NULL</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-OVERRIDE--CAPS" role="macro" condition="since:2.4">
<title>G_IS_PARAM_SPEC_OVERRIDE()</title>
<indexterm zone="G-IS-PARAM-SPEC-OVERRIDE--CAPS" role="2.4"><primary sortas="IS_PARAM_SPEC_OVERRIDE">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>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-OVERRIDE--CAPS"><literal>G_TYPE_PARAM_OVERRIDE</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="G-PARAM-SPEC-OVERRIDE--CAPS" role="macro" condition="since:2.4">
<title>G_PARAM_SPEC_OVERRIDE()</title>
<indexterm zone="G-PARAM-SPEC-OVERRIDE--CAPS" role="2.4"><primary sortas="PARAM_SPEC_OVERRIDE">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="GParamSpecOverride"><type>GParamSpecOverride</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="G-TYPE-PARAM-OVERRIDE--CAPS" role="macro" condition="since:2.4">
<title>G_TYPE_PARAM_OVERRIDE</title>
<indexterm zone="G-TYPE-PARAM-OVERRIDE--CAPS" role="2.4"><primary sortas="TYPE_PARAM_OVERRIDE">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>
</para><para role="since">Since 2.4</para></refsect2>
<refsect2 id="GParamSpecOverride" role="struct" condition="since:2.4">
<title>GParamSpecOverride</title>
<indexterm zone="GParamSpecOverride" role="2.4"><primary sortas="ParamSpecOverride">GParamSpecOverride</primary></indexterm><programlisting>typedef 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>
</para><para role="since">Since 2.4</para></refsect2>
<refsect2 id="g-param-spec-override" role="function" condition="since:2.4">
<title>g_param_spec_override ()</title>
<indexterm zone="g-param-spec-override" role="2.4"><primary sortas="param_spec_override">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>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> the name of the property.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>overridden</parameter>&#160;:</term>
<listitem><simpara> The property that is being overridden
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> the newly created <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.4</para></refsect2>
<refsect2 id="G-IS-PARAM-SPEC-GTYPE--CAPS" role="macro" condition="since:2.10">
<title>G_IS_PARAM_SPEC_GTYPE()</title>
<indexterm zone="G-IS-PARAM-SPEC-GTYPE--CAPS" role="2.10"><primary sortas="IS_PARAM_SPEC_GTYPE">G_IS_PARAM_SPEC_GTYPE</primary></indexterm><programlisting>#define G_IS_PARAM_SPEC_GTYPE(pspec)       (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_GTYPE))
</programlisting>
<para>
Checks whether the given <link linkend="GParamSpec"><type>GParamSpec</type></link> is of type <link linkend="G-TYPE-PARAM-GTYPE--CAPS"><literal>G_TYPE_PARAM_GTYPE</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.10</para></refsect2>
<refsect2 id="G-PARAM-SPEC-GTYPE--CAPS" role="macro" condition="since:2.10">
<title>G_PARAM_SPEC_GTYPE()</title>
<indexterm zone="G-PARAM-SPEC-GTYPE--CAPS" role="2.10"><primary sortas="PARAM_SPEC_GTYPE">G_PARAM_SPEC_GTYPE</primary></indexterm><programlisting>#define G_PARAM_SPEC_GTYPE(pspec)          (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_GTYPE, GParamSpecGType))
</programlisting>
<para>
Casts a <link linkend="GParamSpec"><type>GParamSpec</type></link> into a <link linkend="GParamSpecGType"><type>GParamSpecGType</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>pspec</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GParamSpec"><type>GParamSpec</type></link>
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.10</para></refsect2>
<refsect2 id="G-VALUE-HOLDS-GTYPE--CAPS" role="macro" condition="since:2.12">
<title>G_VALUE_HOLDS_GTYPE()</title>
<indexterm zone="G-VALUE-HOLDS-GTYPE--CAPS" role="2.12"><primary sortas="VALUE_HOLDS_GTYPE">G_VALUE_HOLDS_GTYPE</primary></indexterm><programlisting>#define G_VALUE_HOLDS_GTYPE(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_GTYPE))
</programlisting>
<para>
Checks whether the given <link linkend="GValue"><type>GValue</type></link> can hold values of type <link linkend="G-TYPE-GTYPE--CAPS"><literal>G_TYPE_GTYPE</literal></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> structure
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.12</para></refsect2>
<refsect2 id="G-TYPE-PARAM-GTYPE--CAPS" role="macro" condition="since:2.10">
<title>G_TYPE_PARAM_GTYPE</title>
<indexterm zone="G-TYPE-PARAM-GTYPE--CAPS" role="2.10"><primary sortas="TYPE_PARAM_GTYPE">G_TYPE_PARAM_GTYPE</primary></indexterm><programlisting>#define	G_TYPE_PARAM_GTYPE		   (g_param_spec_types[21])
</programlisting>
<para>
The <link linkend="GType"><type>GType</type></link> of <link linkend="GParamSpecGType"><type>GParamSpecGType</type></link>.</para>
<para>
</para><para role="since">Since 2.10</para></refsect2>
<refsect2 id="GParamSpecGType" role="struct" condition="since:2.10">
<title>GParamSpecGType</title>
<indexterm zone="GParamSpecGType" role="2.10"><primary sortas="ParamSpecGType">GParamSpecGType</primary></indexterm><programlisting>typedef struct {
  GParamSpec    parent_instance;
  GType         is_a_type;
} GParamSpecGType;
</programlisting>
<para>
A <link linkend="GParamSpec"><type>GParamSpec</type></link> derived structure that contains the meta data for <link linkend="GType"><type>GType</type></link> properties.</para>
<para>
</para><variablelist role="struct">
<varlistentry>
<term><link linkend="GParamSpec">GParamSpec</link>&#160;<structfield>parent_instance</structfield>;</term>
<listitem><simpara> private <link linkend="GParamSpec"><type>GParamSpec</type></link> portion
</simpara></listitem>
</varlistentry>
<varlistentry>
<term><link linkend="GType">GType</link>&#160;<structfield>is_a_type</structfield>;</term>
<listitem><simpara> a <link linkend="GType"><type>GType</type></link> whose subtypes can occur as values
</simpara></listitem>
</varlistentry>
</variablelist><para role="since">Since 2.10</para></refsect2>
<refsect2 id="g-param-spec-gtype" role="function" condition="since:2.10">
<title>g_param_spec_gtype ()</title>
<indexterm zone="g-param-spec-gtype" role="2.10"><primary sortas="param_spec_gtype">g_param_spec_gtype</primary></indexterm><programlisting><link linkend="GParamSpec">GParamSpec</link>*         g_param_spec_gtype                  (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> is_a_type,
                                                         <link linkend="GParamFlags">GParamFlags</link> flags);</programlisting>
<para>
Creates a new <link linkend="GParamSpecGType"><type>GParamSpecGType</type></link> instance specifying a
<link linkend="G-TYPE-GTYPE--CAPS"><literal>G_TYPE_GTYPE</literal></link> property.
</para>
<para>
See <link linkend="g-param-spec-internal"><function>g_param_spec_internal()</function></link> for details on property names.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>name</parameter>&#160;:</term>
<listitem><simpara> canonical name of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>nick</parameter>&#160;:</term>
<listitem><simpara> nick name for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>blurb</parameter>&#160;:</term>
<listitem><simpara> description of the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>is_a_type</parameter>&#160;:</term>
<listitem><simpara> a <link linkend="GType"><type>GType</type></link> whose subtypes are allowed as values
 of the property (use <link linkend="G-TYPE-NONE--CAPS"><literal>G_TYPE_NONE</literal></link> for any type)
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>flags</parameter>&#160;:</term>
<listitem><simpara> flags for the property specified
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a newly created parameter specification
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.10</para></refsect2>
<refsect2 id="g-value-get-gtype" role="function" condition="since:2.12">
<title>g_value_get_gtype ()</title>
<indexterm zone="g-value-get-gtype" role="2.12"><primary sortas="value_get_gtype">g_value_get_gtype</primary></indexterm><programlisting><link linkend="GType">GType</link>               g_value_get_gtype                   (const <link linkend="GValue">GValue</link> *value);</programlisting>
<para>
Get the contents of a <link linkend="G-TYPE-GTYPE--CAPS"><literal>G_TYPE_GTYPE</literal></link> <link linkend="GValue"><type>GValue</type></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-GTYPE--CAPS"><literal>G_TYPE_GTYPE</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> the <link linkend="GType"><type>GType</type></link> stored in <parameter>value</parameter>
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.12</para></refsect2>
<refsect2 id="g-value-set-gtype" role="function" condition="since:2.12">
<title>g_value_set_gtype ()</title>
<indexterm zone="g-value-set-gtype" role="2.12"><primary sortas="value_set_gtype">g_value_set_gtype</primary></indexterm><programlisting><link linkend="void">void</link>                g_value_set_gtype                   (<link linkend="GValue">GValue</link> *value,
                                                         <link linkend="GType">GType</link> v_gtype);</programlisting>
<para>
Set the contents of a <link linkend="G-TYPE-GTYPE--CAPS"><literal>G_TYPE_GTYPE</literal></link> <link linkend="GValue"><type>GValue</type></link> to <parameter>v_gtype</parameter>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> a valid <link linkend="GValue"><type>GValue</type></link> of type <link linkend="G-TYPE-GTYPE--CAPS"><literal>G_TYPE_GTYPE</literal></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>v_gtype</parameter>&#160;:</term>
<listitem><simpara> <link linkend="GType"><type>GType</type></link> to be set
</simpara></listitem></varlistentry>
</variablelist><para role="since">Since 2.12</para></refsect2>

</refsect1>



<refsect1 id="gobject-Standard-Parameter-and-Value-Types.see-also">
<title>See Also</title>
#GParamSpec, <link linkend="GValue"><type>GValue</type></link>, <link linkend="g-object-class-install-property"><function>g_object_class_install_property()</function></link>.
</refsect1>

</refentry>
