RubyGems - pango - Versions diffs - 0.90.2-x86-mingw32 - Mend

pango 0.90.2-x86-mingw32

Files changed (1441) hide show

data/vendor/local/share/gtk-doc/html/glib/glib-GVariantType.html ADDED Viewed

@@ -0,0 +1,1815 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>GVariantType</title>
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="index.html" title="GLib Reference Manual">
+<link rel="up" href="glib-data-types.html" title="GLib Data Types">
+<link rel="prev" href="glib-Memory-Allocators.html" title="Memory Allocators">
+<link rel="next" href="glib-GVariant.html" title="GVariant">
+<meta name="generator" content="GTK-Doc V1.14 (XML mode)">
+<link rel="stylesheet" href="style.css" type="text/css">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2">
+<tr valign="middle">
+<td><a accesskey="p" href="glib-Memory-Allocators.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
+<td><a accesskey="u" href="glib-data-types.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
+<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
+<th width="100%" align="center">GLib Reference Manual</th>
+<td><a accesskey="n" href="glib-GVariant.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+</tr>
+<tr><td colspan="5" class="shortcuts">
+<a href="#glib-GVariantType.synopsis" class="shortcut">Top</a>
+                   |
+                  <a href="#glib-GVariantType.description" class="shortcut">Description</a>
+</td></tr>
+</table>
+<div class="refentry" title="GVariantType">
+<a name="glib-GVariantType"></a><div class="titlepage"></div>
+<div class="refnamediv"><table width="100%"><tr>
+<td valign="top">
+<h2><span class="refentrytitle"><a name="glib-GVariantType.top_of_page"></a>GVariantType</span></h2>
+<p>GVariantType — introduction to the GVariant type system</p>
+</td>
+<td valign="top" align="right"></td>
+</tr></table></div>
+<div class="refsynopsisdiv" title="Synopsis">
+<a name="glib-GVariantType.synopsis"></a><h2>Synopsis</h2>
+<pre class="synopsis">
+#include &lt;glib.h&gt;
+                    <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType">GVariantType</a>;
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BOOLEAN:CAPS" title="G_VARIANT_TYPE_BOOLEAN">G_VARIANT_TYPE_BOOLEAN</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BYTE:CAPS" title="G_VARIANT_TYPE_BYTE">G_VARIANT_TYPE_BYTE</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT16:CAPS" title="G_VARIANT_TYPE_INT16">G_VARIANT_TYPE_INT16</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT16:CAPS" title="G_VARIANT_TYPE_UINT16">G_VARIANT_TYPE_UINT16</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT32:CAPS" title="G_VARIANT_TYPE_INT32">G_VARIANT_TYPE_INT32</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT32:CAPS" title="G_VARIANT_TYPE_UINT32">G_VARIANT_TYPE_UINT32</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT64:CAPS" title="G_VARIANT_TYPE_INT64">G_VARIANT_TYPE_INT64</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT64:CAPS" title="G_VARIANT_TYPE_UINT64">G_VARIANT_TYPE_UINT64</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-HANDLE:CAPS" title="G_VARIANT_TYPE_HANDLE">G_VARIANT_TYPE_HANDLE</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DOUBLE:CAPS" title="G_VARIANT_TYPE_DOUBLE">G_VARIANT_TYPE_DOUBLE</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING:CAPS" title="G_VARIANT_TYPE_STRING">G_VARIANT_TYPE_STRING</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-OBJECT-PATH:CAPS" title="G_VARIANT_TYPE_OBJECT_PATH">G_VARIANT_TYPE_OBJECT_PATH</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-SIGNATURE:CAPS" title="G_VARIANT_TYPE_SIGNATURE">G_VARIANT_TYPE_SIGNATURE</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-VARIANT:CAPS" title="G_VARIANT_TYPE_VARIANT">G_VARIANT_TYPE_VARIANT</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ANY:CAPS" title="G_VARIANT_TYPE_ANY">G_VARIANT_TYPE_ANY</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BASIC:CAPS" title="G_VARIANT_TYPE_BASIC">G_VARIANT_TYPE_BASIC</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-MAYBE:CAPS" title="G_VARIANT_TYPE_MAYBE">G_VARIANT_TYPE_MAYBE</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY">G_VARIANT_TYPE_ARRAY</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE">G_VARIANT_TYPE_TUPLE</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UNIT:CAPS" title="G_VARIANT_TYPE_UNIT">G_VARIANT_TYPE_UNIT</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICT-ENTRY:CAPS" title="G_VARIANT_TYPE_DICT_ENTRY">G_VARIANT_TYPE_DICT_ENTRY</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICTIONARY:CAPS" title="G_VARIANT_TYPE_DICTIONARY">G_VARIANT_TYPE_DICTIONARY</a>
+#define             <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE:CAPS" title="G_VARIANT_TYPE()">G_VARIANT_TYPE</a>                      (type_string)
+<span class="returnvalue">void</span>                <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()">g_variant_type_free</a>                 (<em class="parameter"><code><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-copy" title="g_variant_type_copy ()">g_variant_type_copy</a>                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new" title="g_variant_type_new ()">g_variant_type_new</a>                  (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()">g_variant_type_string_is_valid</a>      (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-string-scan" title="g_variant_type_string_scan ()">g_variant_type_string_scan</a>          (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *string</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *limit</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> **endptr</code></em>);
+<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               <a class="link" href="glib-GVariantType.html#g-variant-type-get-string-length" title="g_variant_type_get_string_length ()">g_variant_type_get_string_length</a>    (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *       <a class="link" href="glib-GVariantType.html#g-variant-type-peek-string" title="g_variant_type_peek_string ()">g_variant_type_peek_string</a>          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *             <a class="link" href="glib-GVariantType.html#g-variant-type-dup-string" title="g_variant_type_dup_string ()">g_variant_type_dup_string</a>           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-definite" title="g_variant_type_is_definite ()">g_variant_type_is_definite</a>          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-container" title="g_variant_type_is_container ()">g_variant_type_is_container</a>         (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-basic" title="g_variant_type_is_basic ()">g_variant_type_is_basic</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-maybe" title="g_variant_type_is_maybe ()">g_variant_type_is_maybe</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-array" title="g_variant_type_is_array ()">g_variant_type_is_array</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-tuple" title="g_variant_type_is_tuple ()">g_variant_type_is_tuple</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-dict-entry" title="g_variant_type_is_dict_entry ()">g_variant_type_is_dict_entry</a>        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-variant" title="g_variant_type_is_variant ()">g_variant_type_is_variant</a>           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a>               <a class="link" href="glib-GVariantType.html#g-variant-type-hash" title="g_variant_type_hash ()">g_variant_type_hash</a>                 (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-equal" title="g_variant_type_equal ()">g_variant_type_equal</a>                (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type1</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type2</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-GVariantType.html#g-variant-type-is-subtype-of" title="g_variant_type_is_subtype_of ()">g_variant_type_is_subtype_of</a>        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *supertype</code></em>);
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-maybe" title="g_variant_type_new_maybe ()">g_variant_type_new_maybe</a>            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-array" title="g_variant_type_new_array ()">g_variant_type_new_array</a>            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-tuple" title="g_variant_type_new_tuple ()">g_variant_type_new_tuple</a>            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> * const *items</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="type">gint</span></a> length</code></em>);
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      <a class="link" href="glib-GVariantType.html#g-variant-type-new-dict-entry" title="g_variant_type_new_dict_entry ()">g_variant_type_new_dict_entry</a>       (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *key</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *value</code></em>);
+const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-element" title="g_variant_type_element ()">g_variant_type_element</a>             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               <a class="link" href="glib-GVariantType.html#g-variant-type-n-items" title="g_variant_type_n_items ()">g_variant_type_n_items</a>              (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-first" title="g_variant_type_first ()">g_variant_type_first</a>               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-next" title="g_variant_type_next ()">g_variant_type_next</a>                (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-key" title="g_variant_type_key ()">g_variant_type_key</a>                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * <a class="link" href="glib-GVariantType.html#g-variant-type-value" title="g_variant_type_value ()">g_variant_type_value</a>               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);
+</pre>
+</div>
+<div class="refsect1" title="Description">
+<a name="glib-GVariantType.description"></a><h2>Description</h2>
+<p>
+This section introduces the GVariant type system.  It is based, in
+large part, on the DBus type system, with two major changes and some minor
+lifting of restrictions.  The <a class="ulink" href="http://dbus.freedesktop.org/doc/dbus-specification.html" target="_top">DBus
+specification</a>, therefore, provides a significant amount of
+information that is useful when working with GVariant.
+</p>
+<p>
+The first major change with respect to the DBus type system is the
+introduction of maybe (or "nullable") types.  Any type in GVariant can be
+converted to a maybe type, in which case, "nothing" (or "null") becomes a
+valid value.  Maybe types have been added by introducing the
+character "<code class="literal">m</code>" to type strings.
+</p>
+<p>
+The second major change is that the GVariant type system supports the
+concept of "indefinite types" -- types that are less specific than
+the normal types found in DBus.  For example, it is possible to speak
+of "an array of any type" in GVariant, where the DBus type system
+would require you to speak of "an array of integers" or "an array of
+strings".  Indefinite types have been added by introducing the
+characters "<code class="literal">*</code>", "<code class="literal">?</code>" and
+"<code class="literal">r</code>" to type strings.
+</p>
+<p>
+Finally, all arbitrary restrictions relating to the complexity of
+types are lifted along with the restriction that dictionary entries
+may only appear nested inside of arrays.
+</p>
+<p>
+Just as in DBus, GVariant types are described with strings ("type
+strings").  Subject to the differences mentioned above, these strings
+are of the same form as those found in DBus.  Note, however: DBus
+always works in terms of messages and therefore individual type
+strings appear nowhere in its interface.  Instead, "signatures"
+are a concatenation of the strings of the type of each argument in a
+message.  GVariant deals with single values directly so GVariant type
+strings always describe the type of exactly one value.  This means
+that a DBus signature string is generally not a valid GVariant type
+string -- except in the case that it is the signature of a message
+containing exactly one argument.
+</p>
+<p>
+An indefinite type is similar in spirit to what may be called an
+abstract type in other type systems.  No value can exist that has an
+indefinite type as its type, but values can exist that have types
+that are subtypes of indefinite types.  That is to say,
+<a class="link" href="glib-GVariant.html#g-variant-get-type" title="g_variant_get_type ()"><code class="function">g_variant_get_type()</code></a> will never return an indefinite type, but
+calling <code class="function">g_variant_is_a()</code> with an indefinite type may return <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a>.
+For example, you can not have a value that represents "an array of no
+particular type", but you can have an "array of integers" which
+certainly matches the type of "an array of no particular type", since
+"array of integers" is a subtype of "array of no particular type".
+</p>
+<p>
+This is similar to how instances of abstract classes may not
+directly exist in other type systems, but instances of their
+non-abstract subtypes may.  For example, in GTK, no object that has
+the type of <span class="type">GtkBin</span> can exist (since <span class="type">GtkBin</span> is an abstract class),
+but a <span class="type">GtkWindow</span> can certainly be instantiated, and you would say
+that the <span class="type">GtkWindow</span> is a <span class="type">GtkBin</span> (since <span class="type">GtkWindow</span> is a subclass of
+<span class="type">GtkBin</span>).
+</p>
+<p>
+A detailed description of GVariant type strings is given here:
+</p>
+<div class="refsect2" title="GVariant Type Strings">
+<a name="gvariant-typestrings"></a><h3>GVariant Type Strings</h3>
+<p>
+  A GVariant type string can be any of the following:
+ </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem"><p>
+    any basic type string (listed below)
+   </p></li>
+<li class="listitem"><p>
+    "<code class="literal">v</code>", "<code class="literal">r</code>" or
+    "<code class="literal">*</code>"
+   </p></li>
+<li class="listitem"><p>
+    one of the characters '<code class="literal">a</code>' or
+    '<code class="literal">m</code>', followed by another type string
+   </p></li>
+<li class="listitem"><p>
+    the character '<code class="literal">(</code>', followed by a concatenation
+    of zero or more other type strings, followed by the character
+    '<code class="literal">)</code>'
+   </p></li>
+<li class="listitem"><p>
+    the character '<code class="literal">{</code>', followed by a basic type
+    string (see below), followed by another type string, followed by
+    the character '<code class="literal">}</code>'
+   </p></li>
+</ul></div>
+<p>
+  A basic type string describes a basic type (as per
+  <a class="link" href="glib-GVariantType.html#g-variant-type-is-basic" title="g_variant_type_is_basic ()"><code class="function">g_variant_type_is_basic()</code></a>) and is always a single
+  character in length.  The valid basic type strings are
+  "<code class="literal">b</code>", "<code class="literal">y</code>",
+  "<code class="literal">n</code>", "<code class="literal">q</code>",
+  "<code class="literal">i</code>", "<code class="literal">u</code>",
+  "<code class="literal">x</code>", "<code class="literal">t</code>",
+  "<code class="literal">h</code>", "<code class="literal">d</code>",
+  "<code class="literal">s</code>", "<code class="literal">o</code>",
+  "<code class="literal">g</code>" and "<code class="literal">?</code>".
+ </p>
+<p>
+  The above definition is recursive to arbitrary depth.
+  "<code class="literal">aaaaai</code>" and "<code class="literal">(ui(nq((y)))s)</code>"
+  are both valid type strings, as is
+  "<code class="literal">a(aa(ui)(qna{ya(yd)}))</code>".
+ </p>
+<p>
+  The meaning of each of the characters is as follows:
+ </p>
+<div class="informaltable"><table border="1">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<tbody>
+<tr>
+<td>
+      <p>
+       <span class="strong"><strong>Character</strong></span>
+      </p>
+     </td>
+<td>
+      <p>
+       <span class="strong"><strong>Meaning</strong></span>
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">b</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BOOLEAN:CAPS" title="G_VARIANT_TYPE_BOOLEAN"><code class="literal">G_VARIANT_TYPE_BOOLEAN</code></a>; a boolean value.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">y</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BYTE:CAPS" title="G_VARIANT_TYPE_BYTE"><code class="literal">G_VARIANT_TYPE_BYTE</code></a>; a byte.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">n</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT16:CAPS" title="G_VARIANT_TYPE_INT16"><code class="literal">G_VARIANT_TYPE_INT16</code></a>; a signed 16 bit
+       integer.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">q</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT16:CAPS" title="G_VARIANT_TYPE_UINT16"><code class="literal">G_VARIANT_TYPE_UINT16</code></a>; an unsigned 16 bit
+       integer.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">i</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT32:CAPS" title="G_VARIANT_TYPE_INT32"><code class="literal">G_VARIANT_TYPE_INT32</code></a>; a signed 32 bit
+       integer.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">u</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT32:CAPS" title="G_VARIANT_TYPE_UINT32"><code class="literal">G_VARIANT_TYPE_UINT32</code></a>; an unsigned 32 bit
+       integer.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">x</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-INT64:CAPS" title="G_VARIANT_TYPE_INT64"><code class="literal">G_VARIANT_TYPE_INT64</code></a>; a signed 64 bit
+       integer.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">t</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UINT64:CAPS" title="G_VARIANT_TYPE_UINT64"><code class="literal">G_VARIANT_TYPE_UINT64</code></a>; an unsigned 64 bit
+       integer.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">h</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-HANDLE:CAPS" title="G_VARIANT_TYPE_HANDLE"><code class="literal">G_VARIANT_TYPE_HANDLE</code></a>; a signed 32 bit
+       value that, by convention, is used as an index into an array
+       of file descriptors that are sent alongside a DBus message.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">d</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DOUBLE:CAPS" title="G_VARIANT_TYPE_DOUBLE"><code class="literal">G_VARIANT_TYPE_DOUBLE</code></a>; a double precision
+       floating point value.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">s</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING:CAPS" title="G_VARIANT_TYPE_STRING"><code class="literal">G_VARIANT_TYPE_STRING</code></a>; a string.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">o</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-OBJECT-PATH:CAPS" title="G_VARIANT_TYPE_OBJECT_PATH"><code class="literal">G_VARIANT_TYPE_OBJECT_PATH</code></a>; a string in
+       the form of a DBus object path.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">g</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-STRING:CAPS" title="G_VARIANT_TYPE_STRING"><code class="literal">G_VARIANT_TYPE_STRING</code></a>; a string in the
+       form of a DBus type signature.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">?</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BASIC:CAPS" title="G_VARIANT_TYPE_BASIC"><code class="literal">G_VARIANT_TYPE_BASIC</code></a>; an indefinite type
+       that is a supertype of any of the basic types.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">v</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-VARIANT:CAPS" title="G_VARIANT_TYPE_VARIANT"><code class="literal">G_VARIANT_TYPE_VARIANT</code></a>; a container type
+       that contain any other type of value.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">a</code>
+      </p>
+     </td>
+<td>
+      <p>
+       used as a prefix on another type string to mean an array of
+       that type; the type string "<code class="literal">ai</code>", for
+       example, is the type of an array of 32 bit signed integers.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">m</code>
+      </p>
+     </td>
+<td>
+      <p>
+       used as a prefix on another type string to mean a "maybe", or
+       "nullable", version of that type; the type string
+       "<code class="literal">ms</code>", for example, is the type of a value
+       that maybe contains a string, or maybe contains nothing.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">()</code>
+      </p>
+     </td>
+<td>
+      <p>
+       used to enclose zero or more other concatenated type strings
+       to create a tuple type; the type string
+       "<code class="literal">(is)</code>", for example, is the type of a pair
+       of an integer and a string.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">r</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>; an indefinite type
+       that is a supertype of any tuple type, regardless of the
+       number of items.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">{}</code>
+      </p>
+     </td>
+<td>
+      <p>
+       used to enclose a basic type string concatenated with another
+       type string to create a dictionary entry type, which usually
+       appears inside of an array to form a dictionary; the type
+       string "<code class="literal">a{sd}</code>", for example, is the type of
+       a dictionary that maps strings to double precision floating
+       point values.
+      </p>
+      <p>
+       The first type (the basic type) is the key type and the second
+       type is the value type.  The reason that the first type is
+       restricted to being a basic type is so that it can easily be
+       hashed.
+      </p>
+     </td>
+</tr>
+<tr>
+<td>
+      <p>
+       <code class="literal">*</code>
+      </p>
+     </td>
+<td>
+      <p>
+       the type string of <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ANY:CAPS" title="G_VARIANT_TYPE_ANY"><code class="literal">G_VARIANT_TYPE_ANY</code></a>; the indefinite type
+       that is a supertype of all types.  Note that, as with all type
+       strings, this character represents exactly one type.  It
+       cannot be used inside of tuples to mean "any number of items".
+      </p>
+     </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+  Any type string of a container that contains an indefinite type is,
+  itself, an indefinite type.  For example, the type string
+  "<code class="literal">a*</code>" (corresponding to <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>) is
+  an indefinite type that is a supertype of every array type.
+  "<code class="literal">(*s)</code>" is a supertype of all tuples that
+  contain exactly two items where the second item is a string.
+ </p>
+<p>
+  "<code class="literal">a{?*}</code>" is an indefinite type that is a
+  supertype of all arrays containing dictionary entries where the key
+  is any basic type and the value is any type at all.  This is, by
+  definition, a dictionary, so this type string corresponds to
+  <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICTIONARY:CAPS" title="G_VARIANT_TYPE_DICTIONARY"><code class="literal">G_VARIANT_TYPE_DICTIONARY</code></a>.  Note that, due to the restriction that
+  the key of a dictionary entry must be a basic type,
+  "<code class="literal">{**}</code>" is not a valid type string.
+ </p>
+</div>
+</div>
+<div class="refsect1" title="Details">
+<a name="glib-GVariantType.details"></a><h2>Details</h2>
+<div class="refsect2" title="GVariantType">
+<a name="GVariantType"></a><h3>GVariantType</h3>
+<pre class="programlisting">typedef struct _GVariantType GVariantType;</pre>
+<p>
+A type in the GVariant type system.
+</p>
+<p>
+Two types may not be compared by value; use <a class="link" href="glib-GVariantType.html#g-variant-type-equal" title="g_variant_type_equal ()"><code class="function">g_variant_type_equal()</code></a> or
+<code class="function">g_variant_type_is_subtype()</code>.  May be copied using
+<a class="link" href="glib-GVariantType.html#g-variant-type-copy" title="g_variant_type_copy ()"><code class="function">g_variant_type_copy()</code></a> and freed using <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a>.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_BOOLEAN">
+<a name="G-VARIANT-TYPE-BOOLEAN:CAPS"></a><h3>G_VARIANT_TYPE_BOOLEAN</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_BOOLEAN              ((const GVariantType *) "b")
+</pre>
+<p>
+The type of a value that can be either <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> or <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a>.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_BYTE">
+<a name="G-VARIANT-TYPE-BYTE:CAPS"></a><h3>G_VARIANT_TYPE_BYTE</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_BYTE                 ((const GVariantType *) "y")
+</pre>
+<p>
+The type of an integer value that can range from 0 to 255.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_INT16">
+<a name="G-VARIANT-TYPE-INT16:CAPS"></a><h3>G_VARIANT_TYPE_INT16</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_INT16                ((const GVariantType *) "n")
+</pre>
+<p>
+The type of an integer value that can range from -32768 to 32767.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_UINT16">
+<a name="G-VARIANT-TYPE-UINT16:CAPS"></a><h3>G_VARIANT_TYPE_UINT16</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_UINT16               ((const GVariantType *) "q")
+</pre>
+<p>
+The type of an integer value that can range from 0 to 65535.
+There were about this many people living in Toronto in the 1870s.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_INT32">
+<a name="G-VARIANT-TYPE-INT32:CAPS"></a><h3>G_VARIANT_TYPE_INT32</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_INT32                ((const GVariantType *) "i")
+</pre>
+<p>
+The type of an integer value that can range from -2147483648 to
+2147483647.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_UINT32">
+<a name="G-VARIANT-TYPE-UINT32:CAPS"></a><h3>G_VARIANT_TYPE_UINT32</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_UINT32               ((const GVariantType *) "u")
+</pre>
+<p>
+The type of an integer value that can range from 0 to 4294967295.
+That's one number for everyone who was around in the late 1970s.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_INT64">
+<a name="G-VARIANT-TYPE-INT64:CAPS"></a><h3>G_VARIANT_TYPE_INT64</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_INT64                ((const GVariantType *) "x")
+</pre>
+<p>
+The type of an integer value that can range from
+-9223372036854775808 to 9223372036854775807.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_UINT64">
+<a name="G-VARIANT-TYPE-UINT64:CAPS"></a><h3>G_VARIANT_TYPE_UINT64</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_UINT64               ((const GVariantType *) "t")
+</pre>
+<p>
+The type of an integer value that can range from 0 to
+18446744073709551616.  That's a really big number, but a Rubik's
+cube can have a bit more than twice as many possible positions.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_HANDLE">
+<a name="G-VARIANT-TYPE-HANDLE:CAPS"></a><h3>G_VARIANT_TYPE_HANDLE</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_HANDLE               ((const GVariantType *) "h")
+</pre>
+<p>
+The type of a 32bit signed integer value, that by convention, is used
+as an index into an array of file descriptors that are sent alongside
+a DBus message.
+</p>
+<p>
+If you are not interacting with DBus, then there is no reason to make
+use of this type.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_DOUBLE">
+<a name="G-VARIANT-TYPE-DOUBLE:CAPS"></a><h3>G_VARIANT_TYPE_DOUBLE</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_DOUBLE               ((const GVariantType *) "d")
+</pre>
+<p>
+The type of a double precision IEEE754 floating point number.
+These guys go up to about 1.80e308 (plus and minus) but miss out on
+some numbers in between.  In any case, that's far greater than the
+estimated number of fundamental particles in the observable
+universe.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_STRING">
+<a name="G-VARIANT-TYPE-STRING:CAPS"></a><h3>G_VARIANT_TYPE_STRING</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_STRING               ((const GVariantType *) "s")
+</pre>
+<p>
+The type of a string.  "" is a string.  <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> is not a string.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_OBJECT_PATH">
+<a name="G-VARIANT-TYPE-OBJECT-PATH:CAPS"></a><h3>G_VARIANT_TYPE_OBJECT_PATH</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_OBJECT_PATH          ((const GVariantType *) "o")
+</pre>
+<p>
+The type of a DBus object reference.  These are strings of a
+specific format used to identify objects at a given destination on
+the bus.
+</p>
+<p>
+If you are not interacting with DBus, then there is no reason to make
+use of this type.  If you are, then the DBus specification contains a
+precise description of valid object paths.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_SIGNATURE">
+<a name="G-VARIANT-TYPE-SIGNATURE:CAPS"></a><h3>G_VARIANT_TYPE_SIGNATURE</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_SIGNATURE            ((const GVariantType *) "g")
+</pre>
+<p>
+The type of a DBus type signature.  These are strings of a specific
+format used as type signatures for DBus methods and messages.
+</p>
+<p>
+If you are not interacting with DBus, then there is no reason to make
+use of this type.  If you are, then the DBus specification contains a
+precise description of valid signature strings.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_VARIANT">
+<a name="G-VARIANT-TYPE-VARIANT:CAPS"></a><h3>G_VARIANT_TYPE_VARIANT</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_VARIANT              ((const GVariantType *) "v")
+</pre>
+<p>
+The type of a box that contains any other value (including another
+variant).
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_ANY">
+<a name="G-VARIANT-TYPE-ANY:CAPS"></a><h3>G_VARIANT_TYPE_ANY</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_ANY                  ((const GVariantType *) "*")
+</pre>
+<p>
+An indefinite type that is a supertype of every type (including
+itself).
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_BASIC">
+<a name="G-VARIANT-TYPE-BASIC:CAPS"></a><h3>G_VARIANT_TYPE_BASIC</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_BASIC                ((const GVariantType *) "?")
+</pre>
+<p>
+An indefinite type that is a supertype of every basic (ie:
+non-container) type.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_MAYBE">
+<a name="G-VARIANT-TYPE-MAYBE:CAPS"></a><h3>G_VARIANT_TYPE_MAYBE</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_MAYBE                ((const GVariantType *) "m*")
+</pre>
+<p>
+An indefinite type that is a supertype of every maybe type.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_ARRAY">
+<a name="G-VARIANT-TYPE-ARRAY:CAPS"></a><h3>G_VARIANT_TYPE_ARRAY</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_ARRAY                ((const GVariantType *) "a*")
+</pre>
+<p>
+An indefinite type that is a supertype of every array type.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_TUPLE">
+<a name="G-VARIANT-TYPE-TUPLE:CAPS"></a><h3>G_VARIANT_TYPE_TUPLE</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_TUPLE                ((const GVariantType *) "r")
+</pre>
+<p>
+An indefinite type that is a supertype of every tuple type,
+regardless of the number of items in the tuple.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_UNIT">
+<a name="G-VARIANT-TYPE-UNIT:CAPS"></a><h3>G_VARIANT_TYPE_UNIT</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_UNIT                 ((const GVariantType *) "()")
+</pre>
+<p>
+The empty tuple type.  Has only one instance.  Known also as "triv"
+or "void".
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_DICT_ENTRY">
+<a name="G-VARIANT-TYPE-DICT-ENTRY:CAPS"></a><h3>G_VARIANT_TYPE_DICT_ENTRY</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_DICT_ENTRY           ((const GVariantType *) "{?*}")
+</pre>
+<p>
+An indefinite type that is a supertype of every dictionary entry
+type.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE_DICTIONARY">
+<a name="G-VARIANT-TYPE-DICTIONARY:CAPS"></a><h3>G_VARIANT_TYPE_DICTIONARY</h3>
+<pre class="programlisting">#define G_VARIANT_TYPE_DICTIONARY           ((const GVariantType *) "a{?*}")
+</pre>
+<p>
+An indefinite type that is a supertype of every dictionary type --
+that is, any array type that has an element type equal to any
+dictionary entry type.
+</p>
+</div>
+<hr>
+<div class="refsect2" title="G_VARIANT_TYPE()">
+<a name="G-VARIANT-TYPE:CAPS"></a><h3>G_VARIANT_TYPE()</h3>
+<pre class="programlisting">#define             G_VARIANT_TYPE(type_string)</pre>
+<p>
+Converts a string to a const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>.  Depending on the
+current debugging level, this function may perform a runtime check
+to ensure that <em class="parameter"><code>string</code></em> is a valid GVariant type string.
+</p>
+<p>
+It is always a programmer error to use this macro with an invalid
+type string.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody><tr>
+<td><p><span class="term"><em class="parameter"><code>type_string</code></em> :</span></p></td>
+<td>a well-formed <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> type string
+</td>
+</tr></tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_free ()">
+<a name="g-variant-type-free"></a><h3>g_variant_type_free ()</h3>
+<pre class="programlisting"><span class="returnvalue">void</span>                g_variant_type_free                 (<em class="parameter"><code><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Frees a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> that was allocated with
+<a class="link" href="glib-GVariantType.html#g-variant-type-copy" title="g_variant_type_copy ()"><code class="function">g_variant_type_copy()</code></a>, <a class="link" href="glib-GVariantType.html#g-variant-type-new" title="g_variant_type_new ()"><code class="function">g_variant_type_new()</code></a> or one of the container
+type constructor functions.
+</p>
+<p>
+In the case that <em class="parameter"><code>type</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>, this function does nothing.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody><tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
+</td>
+</tr></tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_copy ()">
+<a name="g-variant-type-copy"></a><h3>g_variant_type_copy ()</h3>
+<pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_copy                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Makes a copy of a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>.  It is appropriate to call
+<a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.  <em class="parameter"><code>type</code></em> may not be <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>a new <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_new ()">
+<a name="g-variant-type-new"></a><h3>g_variant_type_new ()</h3>
+<pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new                  (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);</pre>
+<p>
+Creates a new <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> corresponding to the type string given
+by <em class="parameter"><code>type_string</code></em>.  It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on
+the return value.
+</p>
+<p>
+It is a programmer error to call this function with an invalid type
+string.  Use <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()"><code class="function">g_variant_type_string_is_valid()</code></a> if you are unsure.
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type_string</code></em> :</span></p></td>
+<td>a valid GVariant type string
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>a new <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+<p class="since">Since 2.24</p>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_string_is_valid ()">
+<a name="g-variant-type-string-is-valid"></a><h3>g_variant_type_string_is_valid ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_string_is_valid      (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *type_string</code></em>);</pre>
+<p>
+Checks if <em class="parameter"><code>type_string</code></em> is a valid GVariant type string.  This call is
+equivalent to calling <a class="link" href="glib-GVariantType.html#g-variant-type-string-scan" title="g_variant_type_string_scan ()"><code class="function">g_variant_type_string_scan()</code></a> and confirming
+that the following character is a nul terminator.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type_string</code></em> :</span></p></td>
+<td>a pointer to any string
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type_string</code></em> is exactly one valid type string
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_string_scan ()">
+<a name="g-variant-type-string-scan"></a><h3>g_variant_type_string_scan ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_string_scan          (<em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *string</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> *limit</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="type">gchar</span></a> **endptr</code></em>);</pre>
+<p>
+Scan for a single complete and valid GVariant type string in <em class="parameter"><code>string</code></em>.
+The memory pointed to by <em class="parameter"><code>limit</code></em> (or bytes beyond it) is never
+accessed.
+</p>
+<p>
+If a valid type string is found, <em class="parameter"><code>endptr</code></em> is updated to point to the
+first character past the end of the string that was found and <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a>
+is returned.
+</p>
+<p>
+If there is no valid type string starting at <em class="parameter"><code>string</code></em>, or if the type
+string does not end before <em class="parameter"><code>limit</code></em> then <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> is returned.
+</p>
+<p>
+For the simple case of checking if a string is a valid type string,
+see <a class="link" href="glib-GVariantType.html#g-variant-type-string-is-valid" title="g_variant_type_string_is_valid ()"><code class="function">g_variant_type_string_is_valid()</code></a>.
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>string</code></em> :</span></p></td>
+<td>a pointer to any string
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>limit</code></em> :</span></p></td>
+<td>the end of <em class="parameter"><code>string</code></em>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>endptr</code></em> :</span></p></td>
+<td>location to store the end pointer, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if a valid type string was found
+</td>
+</tr>
+</tbody>
+</table></div>
+<p class="since">Since 2.24</p>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_get_string_length ()">
+<a name="g-variant-type-get-string-length"></a><h3>g_variant_type_get_string_length ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               g_variant_type_get_string_length    (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Returns the length of the type string corresponding to the given
+<em class="parameter"><code>type</code></em>.  This function must be used to determine the valid extent of
+the memory region returned by <a class="link" href="glib-GVariantType.html#g-variant-type-peek-string" title="g_variant_type_peek_string ()"><code class="function">g_variant_type_peek_string()</code></a>.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the length of the corresponding type string
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_peek_string ()">
+<a name="g-variant-type-peek-string"></a><h3>g_variant_type_peek_string ()</h3>
+<pre class="programlisting">const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *       g_variant_type_peek_string          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Returns the type string corresponding to the given <em class="parameter"><code>type</code></em>.  The
+result is not nul-terminated; in order to determine its length you
+must call <a class="link" href="glib-GVariantType.html#g-variant-type-get-string-length" title="g_variant_type_get_string_length ()"><code class="function">g_variant_type_get_string_length()</code></a>.
+</p>
+<p>
+To get a nul-terminated string, see <a class="link" href="glib-GVariantType.html#g-variant-type-dup-string" title="g_variant_type_dup_string ()"><code class="function">g_variant_type_dup_string()</code></a>.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the corresponding type string (not nul-terminated)
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_dup_string ()">
+<a name="g-variant-type-dup-string"></a><h3>g_variant_type_dup_string ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *             g_variant_type_dup_string           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Returns a newly-allocated copy of the type string corresponding to
+<em class="parameter"><code>type</code></em>.  The returned string is nul-terminated.  It is appropriate to
+call <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a> on the return value.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the corresponding type string
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_definite ()">
+<a name="g-variant-type-is-definite"></a><h3>g_variant_type_is_definite ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_definite          (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is definite (ie: not indefinite).
+</p>
+<p>
+A type is definite if its type string does not contain any indefinite
+type characters ('*', '?', or 'r').
+</p>
+<p>
+A <a class="link" href="glib-GVariant.html#GVariant" title="GVariant"><span class="type">GVariant</span></a> instance may not have an indefinite type, so calling
+this function on the result of <a class="link" href="glib-GVariant.html#g-variant-get-type" title="g_variant_get_type ()"><code class="function">g_variant_get_type()</code></a> will always
+result in <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> being returned.  Calling this function on an
+indefinite type like <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>, however, will result in
+<a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> being returned.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is definite
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_container ()">
+<a name="g-variant-type-is-container"></a><h3>g_variant_type_is_container ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_container         (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is a container type.
+</p>
+<p>
+Container types are any array, maybe, tuple, or dictionary
+entry types plus the variant type.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
+definite subtype is a container -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>, for
+example.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a container type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_basic ()">
+<a name="g-variant-type-is-basic"></a><h3>g_variant_type_is_basic ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_basic             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is a basic type.
+</p>
+<p>
+Basic types are booleans, bytes, integers, doubles, strings, object
+paths and signatures.
+</p>
+<p>
+Only a basic type may be used as the key of a dictionary entry.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> for all indefinite types except
+<a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-BASIC:CAPS" title="G_VARIANT_TYPE_BASIC"><code class="literal">G_VARIANT_TYPE_BASIC</code></a>.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a basic type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_maybe ()">
+<a name="g-variant-type-is-maybe"></a><h3>g_variant_type_is_maybe ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_maybe             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is a maybe type.  This is true if the
+type string for <em class="parameter"><code>type</code></em> starts with an 'm'.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
+definite subtype is a maybe type -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-MAYBE:CAPS" title="G_VARIANT_TYPE_MAYBE"><code class="literal">G_VARIANT_TYPE_MAYBE</code></a>, for
+example.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a maybe type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_array ()">
+<a name="g-variant-type-is-array"></a><h3>g_variant_type_is_array ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_array             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is an array type.  This is true if the
+type string for <em class="parameter"><code>type</code></em> starts with an 'a'.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
+definite subtype is an array type -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-ARRAY:CAPS" title="G_VARIANT_TYPE_ARRAY"><code class="literal">G_VARIANT_TYPE_ARRAY</code></a>, for
+example.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is an array type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_tuple ()">
+<a name="g-variant-type-is-tuple"></a><h3>g_variant_type_is_tuple ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_tuple             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is a tuple type.  This is true if the
+type string for <em class="parameter"><code>type</code></em> starts with a '(' or if <em class="parameter"><code>type</code></em> is
+<a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
+definite subtype is a tuple type -- <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>, for
+example.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a tuple type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_dict_entry ()">
+<a name="g-variant-type-is-dict-entry"></a><h3>g_variant_type_is_dict_entry ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_dict_entry        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is a dictionary entry type.  This is
+true if the type string for <em class="parameter"><code>type</code></em> starts with a '{'.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> for any indefinite type for which every
+definite subtype is a dictionary entry type --
+<a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-DICT-ENTRY:CAPS" title="G_VARIANT_TYPE_DICT_ENTRY"><code class="literal">G_VARIANT_TYPE_DICT_ENTRY</code></a>, for example.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a dictionary entry type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_variant ()">
+<a name="g-variant-type-is-variant"></a><h3>g_variant_type_is_variant ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_variant           (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines if the given <em class="parameter"><code>type</code></em> is the variant type.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is the variant type
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_hash ()">
+<a name="g-variant-type-hash"></a><h3>g_variant_type_hash ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a>               g_variant_type_hash                 (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type</code></em>);</pre>
+<p>
+Hashes <em class="parameter"><code>type</code></em>.
+</p>
+<p>
+The argument type of <em class="parameter"><code>type</code></em> is only <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> to allow use with
+<a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></a> without function pointer casting.  A valid
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> must be provided.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the hash value
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_equal ()">
+<a name="g-variant-type-equal"></a><h3>g_variant_type_equal ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_equal                (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type1</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> type2</code></em>);</pre>
+<p>
+Compares <em class="parameter"><code>type1</code></em> and <em class="parameter"><code>type2</code></em> for equality.
+</p>
+<p>
+Only returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the types are exactly equal.  Even if one type
+is an indefinite type and the other is a subtype of it, <a class="link" href="glib-Standard-Macros.html#FALSE:CAPS" title="FALSE"><code class="literal">FALSE</code></a> will
+be returned if they are not exactly equal.  If you want to check for
+subtypes, use <a class="link" href="glib-GVariantType.html#g-variant-type-is-subtype-of" title="g_variant_type_is_subtype_of ()"><code class="function">g_variant_type_is_subtype_of()</code></a>.
+</p>
+<p>
+The argument types of <em class="parameter"><code>type1</code></em> and <em class="parameter"><code>type2</code></em> are only <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> to
+allow use with <a class="link" href="glib-Hash-Tables.html#GHashTable" title="GHashTable"><span class="type">GHashTable</span></a> without function pointer casting.  For
+both arguments, a valid <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> must be provided.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type1</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type2</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type1</code></em> and <em class="parameter"><code>type2</code></em> are exactly equal
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_is_subtype_of ()">
+<a name="g-variant-type-is-subtype-of"></a><h3>g_variant_type_is_subtype_of ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_variant_type_is_subtype_of        (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *supertype</code></em>);</pre>
+<p>
+Checks if <em class="parameter"><code>type</code></em> is a subtype of <em class="parameter"><code>supertype</code></em>.
+</p>
+<p>
+This function returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a subtype of <em class="parameter"><code>supertype</code></em>.  All
+types are considered to be subtypes of themselves.  Aside from that,
+only indefinite types can have subtypes.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>supertype</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>
+<a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if <em class="parameter"><code>type</code></em> is a subtype of <em class="parameter"><code>supertype</code></em>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_new_maybe ()">
+<a name="g-variant-type-new-maybe"></a><h3>g_variant_type_new_maybe ()</h3>
+<pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_maybe            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);</pre>
+<p>
+Constructs the type corresponding to a maybe instance containing
+type <em class="parameter"><code>type</code></em> or Nothing.
+</p>
+<p>
+It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>element</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>a new maybe <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_new_array ()">
+<a name="g-variant-type-new-array"></a><h3>g_variant_type_new_array ()</h3>
+<pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_array            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *element</code></em>);</pre>
+<p>
+Constructs the type corresponding to an array of elements of the
+type <em class="parameter"><code>type</code></em>.
+</p>
+<p>
+It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>element</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>a new array <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_new_tuple ()">
+<a name="g-variant-type-new-tuple"></a><h3>g_variant_type_new_tuple ()</h3>
+<pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_tuple            (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> * const *items</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="type">gint</span></a> length</code></em>);</pre>
+<p>
+Constructs a new tuple type, from <em class="parameter"><code>items</code></em>.
+</p>
+<p>
+<em class="parameter"><code>length</code></em> is the number of items in <em class="parameter"><code>items</code></em>, or -1 to indicate that
+<em class="parameter"><code>items</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>-terminated.
+</p>
+<p>
+It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>items</code></em> :</span></p></td>
+<td>an array of <a href="glib-GVariantType.html#GVariantType"><span class="type">GVariantTypes</span></a>, one for each item
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>length</code></em> :</span></p></td>
+<td>the length of <em class="parameter"><code>items</code></em>, or -1
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>a new tuple <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_new_dict_entry ()">
+<a name="g-variant-type-new-dict-entry"></a><h3>g_variant_type_new_dict_entry ()</h3>
+<pre class="programlisting"><a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> *      g_variant_type_new_dict_entry       (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *key</code></em>,
+                                                         <em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *value</code></em>);</pre>
+<p>
+Constructs the type corresponding to a dictionary entry with a key
+of type <em class="parameter"><code>key</code></em> and a value of type <em class="parameter"><code>value</code></em>.
+</p>
+<p>
+It is appropriate to call <a class="link" href="glib-GVariantType.html#g-variant-type-free" title="g_variant_type_free ()"><code class="function">g_variant_type_free()</code></a> on the return value.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>key</code></em> :</span></p></td>
+<td>a basic <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>value</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>a new dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_element ()">
+<a name="g-variant-type-element"></a><h3>g_variant_type_element ()</h3>
+<pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_element             (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines the element type of an array or maybe type.
+</p>
+<p>
+This function may only be used with array or maybe types.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>an array or maybe <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the element type of <em class="parameter"><code>type</code></em>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_n_items ()">
+<a name="g-variant-type-n-items"></a><h3>g_variant_type_n_items ()</h3>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a>               g_variant_type_n_items              (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines the number of items contained in a tuple or
+dictionary entry type.
+</p>
+<p>
+This function may only be used with tuple or dictionary entry types,
+but must not be used with the generic tuple type
+<a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>.
+</p>
+<p>
+In the case of a dictionary entry type, this function will always
+return 2.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a tuple or dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the number of items in <em class="parameter"><code>type</code></em>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_first ()">
+<a name="g-variant-type-first"></a><h3>g_variant_type_first ()</h3>
+<pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_first               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines the first item type of a tuple or dictionary entry
+type.
+</p>
+<p>
+This function may only be used with tuple or dictionary entry types,
+but must not be used with the generic tuple type
+<a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-TUPLE:CAPS" title="G_VARIANT_TYPE_TUPLE"><code class="literal">G_VARIANT_TYPE_TUPLE</code></a>.
+</p>
+<p>
+In the case of a dictionary entry type, this returns the type of
+the key.
+</p>
+<p>
+<a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> is returned in case of <em class="parameter"><code>type</code></em> being <a class="link" href="glib-GVariantType.html#G-VARIANT-TYPE-UNIT:CAPS" title="G_VARIANT_TYPE_UNIT"><code class="literal">G_VARIANT_TYPE_UNIT</code></a>.
+</p>
+<p>
+This call, together with <a class="link" href="glib-GVariantType.html#g-variant-type-next" title="g_variant_type_next ()"><code class="function">g_variant_type_next()</code></a> provides an iterator
+interface over tuple and dictionary entry types.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a tuple or dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the first item type of <em class="parameter"><code>type</code></em>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_next ()">
+<a name="g-variant-type-next"></a><h3>g_variant_type_next ()</h3>
+<pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_next                (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines the next item type of a tuple or dictionary entry
+type.
+</p>
+<p>
+<em class="parameter"><code>type</code></em> must be the result of a previous call to
+<a class="link" href="glib-GVariantType.html#g-variant-type-first" title="g_variant_type_first ()"><code class="function">g_variant_type_first()</code></a> or <a class="link" href="glib-GVariantType.html#g-variant-type-next" title="g_variant_type_next ()"><code class="function">g_variant_type_next()</code></a>.
+</p>
+<p>
+If called on the key type of a dictionary entry then this call
+returns the value type.  If called on the value type of a dictionary
+entry then this call returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
+</p>
+<p>
+For tuples, <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> is returned when <em class="parameter"><code>type</code></em> is the last item in a tuple.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> from a previous call
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the next <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> after <em class="parameter"><code>type</code></em>, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_key ()">
+<a name="g-variant-type-key"></a><h3>g_variant_type_key ()</h3>
+<pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_key                 (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines the key type of a dictionary entry type.
+</p>
+<p>
+This function may only be used with a dictionary entry type.  Other
+than the additional restriction, this call is equivalent to
+<a class="link" href="glib-GVariantType.html#g-variant-type-first" title="g_variant_type_first ()"><code class="function">g_variant_type_first()</code></a>.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the key type of the dictionary entry
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<hr>
+<div class="refsect2" title="g_variant_type_value ()">
+<a name="g-variant-type-value"></a><h3>g_variant_type_value ()</h3>
+<pre class="programlisting">const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="returnvalue">GVariantType</span></a> * g_variant_type_value               (<em class="parameter"><code>const <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a> *type</code></em>);</pre>
+<p>
+Determines the value type of a dictionary entry type.
+</p>
+<p>
+This function may only be used with a dictionary entry type.
+</p>
+<p>
+Since 2.24
+</p>
+<div class="variablelist"><table border="0">
+<col align="left" valign="top">
+<tbody>
+<tr>
+<td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
+<td>a dictionary entry <a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>
+</td>
+</tr>
+<tr>
+<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
+<td>the value type of the dictionary entry
+</td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<div class="refsect1" title="See Also">
+<a name="glib-GVariantType.see-also"></a><h2>See Also</h2>
+<a class="link" href="glib-GVariantType.html#GVariantType" title="GVariantType"><span class="type">GVariantType</span></a>, <a class="link" href="glib-GVariant.html#GVariant" title="GVariant"><span class="type">GVariant</span></a>
+</div>
+</div>
+<div class="footer">
+<hr>
+          Generated by GTK-Doc V1.14</div>
+</body>
+</html>