Initial import of vapigen.

* Initial import of vapigen.

svn path=/trunk/; revision=101

diff --git a/vapigen/AUTHORS b/vapigen/AUTHORS
new file mode 100644 (file)
index 0000000..7acb618
--- /dev/null
+++ b/vapigen/AUTHORS
@@ -0,0 +1 @@
+Jürg Billeter <j@bitron.ch>

diff --git a/vapigen/COPYING b/vapigen/COPYING
new file mode 100644 (file)
index 0000000..5ab7695
--- /dev/null
+++ b/vapigen/COPYING
@@ -0,0 +1,504 @@
+                 GNU LESSER GENERAL PUBLIC LICENSE
+                      Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                           Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+                 GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+\f
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+\f
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                           NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                    END OF TERMS AND CONDITIONS
+\f
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+

diff --git a/vapigen/ChangeLog b/vapigen/ChangeLog
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/vapigen/INSTALL b/vapigen/INSTALL
new file mode 100644 (file)
index 0000000..23e5f25
--- /dev/null
+++ b/vapigen/INSTALL
@@ -0,0 +1,236 @@
+Installation Instructions
+*************************
+
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free
+Software Foundation, Inc.
+
+This file is free documentation; the Free Software Foundation gives
+unlimited permission to copy, distribute and modify it.
+
+Basic Installation
+==================
+
+These are generic installation instructions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  (Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.)
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You only need
+`configure.ac' if you want to change it or regenerate `configure' using
+a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.  If you're
+     using `csh' on an old version of System V, you might need to type
+     `sh ./configure' instead to prevent `csh' from trying to execute
+     `configure' itself.
+
+     Running `configure' takes awhile.  While running, it prints some
+     messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.
+
+  5. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+Compilers and Options
+=====================
+
+Some systems require unusual options for compilation or linking that the
+`configure' script does not know about.  Run `./configure --help' for
+details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   If you have to use a `make' that does not support the `VPATH'
+variable, you have to compile the package for one architecture at a
+time in the source code directory.  After you have installed the
+package for one architecture, use `make distclean' before reconfiguring
+for another architecture.
+
+Installation Names
+==================
+
+By default, `make install' installs the package's commands under
+`/usr/local/bin', include files under `/usr/local/include', etc.  You
+can specify an installation prefix other than `/usr/local' by giving
+`configure' the option `--prefix=PREFIX'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+pass the option `--exec-prefix=PREFIX' to `configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+There may be some features `configure' cannot figure out automatically,
+but needs to determine by the type of machine the package will run on.
+Usually, assuming the package is built to be run on the _same_
+architectures, `configure' can figure that out, but if it prints a
+message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the option `--target=TYPE' to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+If you want to set default values for `configure' scripts to share, you
+can create a site shell script called `config.site' that gives default
+values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).  Here is a another example:
+
+     /bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent
+configuration-related scripts to be executed by `/bin/bash'.
+
+`configure' Invocation
+======================
+
+`configure' recognizes the following options to control how it operates.
+
+`--help'
+`-h'
+     Print a summary of the options to `configure', and exit.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
+

diff --git a/vapigen/Makefile.am b/vapigen/Makefile.am
new file mode 100644 (file)
index 0000000..31f37cd
--- /dev/null
+++ b/vapigen/Makefile.am
@@ -0,0 +1,7 @@
+NULL =
+
+SUBDIRS = \
+       gobject-introspection \
+       gidlgen \
+       vapigen \
+       $(NULL)

diff --git a/vapigen/NEWS b/vapigen/NEWS
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/vapigen/README b/vapigen/README
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/vapigen/configure.ac b/vapigen/configure.ac
new file mode 100644 (file)
index 0000000..c434fc6
--- /dev/null
+++ b/vapigen/configure.ac
@@ -0,0 +1,38 @@
+AC_INIT([vapigen], [0.0.1], [j@bitron.ch], [vapigen])
+AC_CONFIG_SRCDIR([Makefile.am])
+AC_CONFIG_HEADERS(config.h)
+AM_INIT_AUTOMAKE([dist-bzip2])
+
+AM_MAINTAINER_MODE
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_LIBTOOL
+AM_PROG_LEX
+AC_PROG_YACC
+
+AC_PATH_PROG(VALAC, valac, valac)
+AC_SUBST(VALAC)
+
+AC_SUBST(CFLAGS)
+AC_SUBST(CPPFLAGS)
+AC_SUBST(LDFLAGS)
+
+GLIB_REQUIRED=2.10.0
+
+PKG_CHECK_MODULES(GLIB, glib-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED)
+AC_SUBST(GLIB_CFLAGS)
+AC_SUBST(GLIB_LIBS)
+
+VALA_REQUIRED=0.0.3
+
+PKG_CHECK_MODULES(VALA, vala-1.0 >= $VALA_REQUIRED)
+AC_SUBST(VALA_CFLAGS)
+AC_SUBST(VALA_LIBS)
+
+AC_CONFIG_FILES([Makefile
+           gobject-introspection/Makefile
+           gidlgen/Makefile
+           vapigen/Makefile])
+
+AC_OUTPUT

diff --git a/vapigen/gidlgen/Makefile.am b/vapigen/gidlgen/Makefile.am
new file mode 100644 (file)
index 0000000..73ed32e
--- /dev/null
+++ b/vapigen/gidlgen/Makefile.am
@@ -0,0 +1,11 @@
+NULL =
+
+dist_bin_SCRIPTS = \
+       gidlgen \
+       $(NULL)
+
+pkglibexecdir = $(libdir)/vala
+dist_pkglibexec_SCRIPTS = \
+       gapi2xml.pl \
+       gapi_pp.pl \
+       $(NULL)

diff --git a/vapigen/gidlgen/gapi2xml.pl b/vapigen/gidlgen/gapi2xml.pl
new file mode 100755 (executable)
index 0000000..49964ae
--- /dev/null
+++ b/vapigen/gidlgen/gapi2xml.pl
@@ -0,0 +1,1178 @@
+#!/usr/bin/perl
+#
+# gapi2xml.pl : Generates an XML representation of GObject based APIs.
+#
+# Author: Mike Kestner <mkestner@speakeasy.net>
+#
+# Copyright (c) 2001-2003 Mike Kestner
+# Copyright (c) 2003-2004 Novell, Inc.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 2 of the GNU General Public
+# License as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+##############################################################
+
+$debug=0;
+
+use XML::LibXML;
+
+if (!$ARGV[1]) {
+       die "Usage: gapi_pp.pl <srcdir> | gapi2xml.pl <namespace> <outfile>\n";
+}
+
+$ns = $ARGV[0];
+
+##############################################################
+# Check if the filename provided exists.  We parse existing files into
+# a tree and append the namespace to the root node.  If the file doesn't 
+# exist, we create a doc tree and root node to work with.
+##############################################################
+
+if (-e $ARGV[1]) {
+       #parse existing file and get root node.
+       $doc = XML::LibXML->new->parse_file($ARGV[1]);
+       $root = $doc->getDocumentElement();
+} else {
+       $doc = XML::LibXML::Document->new();
+       $root = $doc->createElement('api');
+       $root->setAttribute("version", "1.0");
+       $doc->setDocumentElement($root);
+       $warning_node = XML::LibXML::Comment->new ("\n\n        This file was automatically generated.\n        Please DO NOT MODIFY THIS FILE, modify .metadata files instead.\n\n");
+       $root->appendChild($warning_node);
+}
+
+$ns_elem = $doc->createElement('namespace');
+$ns_elem->setAttribute('name', $ns);
+$root->appendChild($ns_elem);
+
+##############################################################
+# First we parse the input for typedefs, structs, enums, and class_init funcs
+# and put them into temporary hashes.
+##############################################################
+
+while ($line = <STDIN>) {
+       if ($line =~ /typedef\s+(struct\s+\w+\s+)\*+(\w+);/) {
+               $ptrs{$2} = $1;
+       } elsif ($line =~ /typedef\s+(struct\s+\w+)\s+(\w+);/) {
+               next if ($2 =~ /Private$/);
+               # fixme: siiigh
+               $2 = "GdkDrawable" if ($1 eq "_GdkDrawable");
+               $types{$2} = $1;
+       } elsif ($line =~ /typedef\s+struct/) {
+               $sdef = $line;
+               while ($line = <STDIN>) {
+                       $sdef .= $line;
+                       last if ($line =~ /^(deprecated)?}/);
+               }
+               $sdef =~ s!/\*.*?(\*/|\n)!!g;
+               $sdef =~ s/\n\s*//g;
+               $types{$1} = $sdef if ($sdef =~ /.*\}\s*(\w+);/);
+       } elsif ($line =~ /typedef\s+(unsigned\s+\w+)\s+(\**)(\w+);/) {
+               $types{$3} = $1 . $2;
+       } elsif ($line =~ /typedef\s+(\w+)\s+(\**)(\w+);/) {
+               $types{$3} = $1 . $2;
+       } elsif ($line =~ /typedef\s+enum\s+(\w+)\s+(\w+);/) {
+               $etypes{$1} = $2;
+       } elsif ($line =~ /^((deprecated)?typedef\s+)?\benum\b/) {
+               $edef = $line;
+               while ($line = <STDIN>) {
+                       $edef .= $line;
+                       last if ($line =~ /^(deprecated)?}\s*(\w+)?;/);
+               }
+               $edef =~ s/\n\s*//g;
+               $edef =~ s|/\*.*?\*/||g;
+               if ($edef =~ /typedef.*}\s*(\w+);/) {
+                       $ename = $1;
+               } elsif ($edef =~ /^(deprecated)?enum\s+(\w+)\s*{/) {
+                       $ename = $2;
+               } else {
+                       print "Unexpected enum format\n$edef";
+                       next;
+               }
+               $edefs{$ename} = $edef;
+       } elsif ($line =~ /typedef\s+\w+\s*\**\s*\(\*\s*(\w+)\)\s*\(/) {
+               $fname = $1;
+               $fdef = "";
+               while ($line !~ /;/) {
+                       $fdef .= $line;
+                       $line = <STDIN>;
+               }
+               $fdef .= $line;
+               $fdef =~ s/\n\s+//g;
+               $fpdefs{$fname} = $fdef;
+       } elsif ($line =~ /^(private|deprecated)?struct\s+(\w+)/) {
+               next if ($line =~ /;/);
+               $sname = $2;
+               $sdef = $line;
+               while ($line = <STDIN>) {
+                       $sdef .= $line;
+                       last if ($line =~ /^(deprecated)?}/);
+               }
+               $sdef =~ s!/\*[^<].*?(\*/|\n)!!g;
+               $sdef =~ s/\n\s*//g;
+               $sdefs{$sname} = $sdef if (!exists ($sdefs{$sname}));
+       } elsif ($line =~ /^(\w+)_(class|base)_init\b/) {
+               $class = StudlyCaps($1);
+               $pedef = $line;
+               while ($line = <STDIN>) {
+                       $pedef .= $line;
+                       last if ($line =~ /^(deprecated)?}/);
+               }
+               $pedefs{lc($class)} = $pedef;
+       } elsif ($line =~ /^(\w+)_get_type\b/) {
+               $class = StudlyCaps($1);
+               $pedef = $line;
+               while ($line = <STDIN>) {
+                       $pedef .= $line;
+                       if ($line =~ /g_boxed_type_register_static/) {
+                               $boxdef = $line;
+                               while ($line !~ /;/) {
+                                       $boxdef .= ($line = <STDIN>);
+                               }
+                               $boxdef =~ s/\n\s*//g;
+                               $boxdef =~ /\(\"(\w+)\"/;
+                               my $boxtype = $1;
+                               $boxtype =~ s/($ns)Type(\w+)/$ns$2/;
+                               $boxdefs{$boxtype} = $boxdef;
+                       } elsif ($line =~ /g_(enum|flags)_register_static/) {
+                               $pedef =~ /^(\w+_get_type)/;
+                               $enum_gtype{$class} = $1;
+                       }
+                       last if ($line =~ /^(deprecated)?}/);
+               }
+               $typefuncs{lc($class)} = $pedef;
+       } elsif ($line =~ /^G_DEFINE_TYPE_WITH_CODE\s*\(\s*(\w+)/) {
+               $typefuncs{lc($1)} = $line;
+       } elsif ($line =~ /^(deprecated)?(const|G_CONST_RETURN)?\s*(struct\s+)?\w+\s*\**(\s*(const|G_CONST_RETURN)\s*\**)?\s*(\w+)\s*\(/) {
+               $fname = $6;
+               $fdef = "";
+               while ($line !~ /;/) {
+                       $fdef .= $line;
+                       $line = <STDIN>;
+               }
+               $fdef .= $line;
+               $fdef =~ s/\n\s*//g;
+               if ($fdef !~ /^_/) {
+                       $fdefs{$fname} = $fdef;
+               }
+       } elsif ($line =~ /CHECK_(\w*)CAST/) {
+               $cast_macro = $line;
+               while ($line =~ /\\$/) {
+                       $line = <STDIN>;
+                       $cast_macro .= $line;
+               }
+               $cast_macro =~ s/\\\n\s*//g;
+               $cast_macro =~ s/\s+/ /g;
+               if ($cast_macro =~ /G_TYPE_CHECK_(\w+)_CAST.*,\s*(\w+),\s*(\w+)\)/) {
+                       if ($1 eq "INSTANCE") {
+                               $objects{$2} = $3 . $objects{$2};
+                       } else {
+                               $objects{$2} .= ":$3";
+                       }
+               } elsif ($cast_macro =~ /G_TYPE_CHECK_(\w+)_CAST.*,\s*([a-zA-Z0-9]+)_(\w+)_get_type\s*\(\),\s*(\w+)\)/) {
+                       $typename = uc ("$2_type_$3");
+                       if ($1 eq "INSTANCE") {
+                               $objects{$typename} = $4 . $objects{$typename};
+                       } else {
+                               $objects{$typename} .= ":$4";
+                       }
+               } elsif ($cast_macro =~ /GTK_CHECK_CAST.*,\s*(\w+),\s*(\w+)/) {
+                       $objects{$1} = $2 . $objects{$1};
+               } elsif ($cast_macro =~ /GTK_CHECK_CLASS_CAST.*,\s*(\w+),\s*(\w+)/) {
+                       $objects{$1} .= ":$2";
+               } elsif ($cast_macro =~ /GST_IMPLEMENTS_INTERFACE_CHECK_INSTANCE_CAST.*,\s*(\w+),\s*(\w+)/) {
+                       $objects{$1} = $2 . $objects{$1};
+               }
+       } elsif ($line =~ /INSTANCE_GET_INTERFACE.*,\s*(\w+),\s*(\w+)/) {
+               $ifaces{$1} = $2;
+       } elsif ($line =~ /^BUILTIN\s*\{\s*\"(\w+)\".*GTK_TYPE_BOXED/) {
+               $boxdefs{$1} = $line;
+       } elsif ($line =~ /^BUILTIN\s*\{\s*\"(\w+)\".*GTK_TYPE_(ENUM|FLAGS)/) {
+               # ignoring these for now.
+       } elsif ($line =~ /^(deprecated)?\#define/) {
+               my $test_ns = uc ($ns);
+               if ($line =~ /^deprecated\#define\s+(\w+)\s+\"(.*)\"/) {
+                       $defines{"deprecated$1"} = $2;
+               } elsif ($line =~ /\#define\s+(\w+)\s+\"(.*)\"/) {
+                       $defines{$1} = $2;
+               }
+       } elsif ($line !~ /\/\*/) {
+               print $line;
+       }
+}
+
+##############################################################
+# Produce the enum definitions.
+##############################################################
+%enums = ();
+
+foreach $cname (sort(keys(%edefs))) {
+       $ecnt++;
+       $def = $edefs{$cname};
+       $cname = $etypes{$cname} if (exists($etypes{$cname}));
+       $enums{lc($cname)} = $cname;
+       $enum_elem = addNameElem($ns_elem, 'enum', $cname, $ns);
+       if ($def =~ /^deprecated/) {
+               $enum_elem->setAttribute("deprecated", "1");
+               $def =~ s/deprecated//g;
+       }
+       if ($enum_gtype{$cname}) {
+               $enum_elem->setAttribute("get-type", $enum_gtype{$cname});
+       }
+       if ($def =~ /<</) {
+               $enum_elem->setAttribute('type', "flags");
+       } else {
+               $enum_elem->setAttribute('type', "enum");
+       }
+       $def =~ /\{(.*\S)\s*\}/;
+       @vals = split(/,\s*/, $1);
+       $vals[0] =~ s/^\s+//;
+       @v0 = split(/_/, $vals[0]);
+       if (@vals > 1) {
+               $done = 0;
+               for ($idx = 0, $regex = ""; $idx < @v0; $idx++) {
+                       $regex .= ($v0[$idx] . "_");
+                       foreach $val (@vals) {
+                               $done = 1 if ($val !~ /$regex/);
+                       }
+                       last if $done;
+               }
+               $common = join("_", @v0[0..$idx-1]);
+       } else {
+               $common = join("_", @v0[0..$#v0-1]);
+       }
+       
+       foreach $val (@vals) {
+               $val =~ s/=\s*\(\s*(.*\S)\s*\)\s*/= \1/;
+               if ($val =~ /$common\_?(\w+)\s*=\s*(.*)$/) {
+                       $name = $1;
+                       $enumval = $2;
+                       if ($enumval =~ /^(\d+|0x[0-9A-Fa-f]+)u?\s*<<\s*(\d+)$/) {
+                               $enumval = "";
+                       } elsif ($enumval =~ /^$common\_?(\w+)$/) {
+                               $enumval = ""
+                       }
+               } elsif ($val =~ /$common\_?(\w+)/) {
+                       $name = $1; $enumval = "";
+               } else {
+                       die "Unexpected enum value: $val for common value $common\n";
+               }
+
+               $val_elem = addNameElem($enum_elem, 'member');
+               $val_elem->setAttribute('name', "$common\_$name");
+               $val_elem->setAttribute('value', $enumval);
+       }
+}
+
+##############################################################
+# Parse the callbacks.
+##############################################################
+
+foreach $cbname (sort(keys(%fpdefs))) {
+       next if ($cbname =~ /^_/);
+       $cbcnt++;
+       $fdef = $cb = $fpdefs{$cbname};
+       $cb_elem = addNameElem($ns_elem, 'callback', $cbname, $ns);
+       $cb =~ /typedef\s+(.*)\(.*\).*\((.*)\);/;
+       $ret = $1; $params = $2;
+       addReturnElem($cb_elem, $ret);
+       if ($params && ($params ne "void")) {
+               addParamsElem($cb_elem, split(/,/, $params));
+       }
+}
+
+
+##############################################################
+# Parse the interfaces list.   
+##############################################################
+
+foreach $type (sort(keys(%ifaces))) {
+
+       $iface = $ifaces{$type};
+       ($inst, $dontcare) = split(/:/, delete $objects{$type});
+       $initfunc = $pedefs{lc($inst)};
+       $ifacetype = delete $types{$iface};
+       delete $types{$inst};
+       
+       $ifacecnt++;
+       $iface_el = addNameElem($ns_elem, 'interface', $inst, $ns);
+       $iface_el->setAttribute("get-type", "");
+
+       $elem_table{lc($inst)} = $iface_el;
+
+       $classdef = $sdefs{$1} if ($ifacetype =~ /struct\s+(\w+)/);
+       if ($initfunc) {
+               parseInitFunc($iface_el, $initfunc);
+       } else {
+               warn "Don't have an init func for $inst.\n" if $debug;
+               addVirtualMethods ($classdef, $iface_el);
+       }
+}
+
+
+##############################################################
+# Parse the classes by walking the objects list.   
+##############################################################
+
+foreach $type (sort(keys(%objects))) {
+       ($inst, $class) = split(/:/, $objects{$type});
+       $class = $inst . "Class" if (!$class);
+       $initfunc = $pedefs{lc($inst)};
+       $typefunc = $typefuncs{lc($inst)};
+       $insttype = delete $types{$inst};
+       $classtype = delete $types{$class};
+
+       $instdef = $classdef = "";
+       $instdef = $sdefs{$1} if ($insttype =~ /struct\s+(\w+)/);
+       $classdef = $sdefs{$1} if ($classtype =~ /struct\s+(\w+)/);
+       $classdef =~ s/deprecated//g;
+       $instdef =~ s/\s+(\*+)([^\/])/\1 \2/g;
+       warn "Strange Class $inst\n" if (!$instdef && $debug);
+
+       $classcnt++;
+       $obj_el = addNameElem($ns_elem, 'object', $inst, $ns);
+       $obj_el->setAttribute("get-type", "");
+
+
+       $elem_table{lc($inst)} = $obj_el;
+
+       # Check if the object is deprecated
+       if ($instdef =~ /^deprecatedstruct/) {
+               $obj_el->setAttribute("deprecated", "1");
+               $instdef =~ s/deprecated//g;
+       }
+       
+       # Extract parent and fields from the struct
+       if ($instdef =~ /^struct/) {
+               $instdef =~ /\{(.*)\}/;
+               $fieldstr = $1;
+               $fieldstr =~ s|/\*[^<].*?\*/||g;
+               @fields = split(/;/, $fieldstr);
+               addFieldElems($obj_el, 'private', @fields);
+               if ($inst =~ /GdkWindow/) {
+                       $obj_el->setAttribute('parent', "GdkDrawable");
+               } else {
+                       $obj_el->setAttribute('parent', $obj_el->firstChild->getAttribute('type'));
+               }
+               $obj_el->removeChild($obj_el->firstChild);
+       } elsif ($instdef =~ /privatestruct/) {
+               # just get the parent for private structs
+               $instdef =~ /\{\s*(\w+)/;
+               $obj_el->setAttribute('parent', "$1");
+       }
+
+       # Get the props from the class_init func.
+       if ($initfunc) {
+               parseInitFunc($obj_el, $initfunc);
+       } else {
+               warn "Don't have an init func for $inst.\n" if $debug;
+       }
+
+       # Get the interfaces from the class_init func.
+       if ($typefunc) {
+               if ($typefunc =~ /G_DEFINE_TYPE_WITH_CODE/) {
+                       parseTypeFuncMacro($obj_el, $typefunc);
+               } else {
+                       parseTypeFunc($obj_el, $typefunc);
+               }
+       } else {
+               warn "Don't have a GetType func for $inst.\n" if $debug;
+       }
+
+}
+
+##############################################################
+# Parse the remaining types.
+##############################################################
+
+foreach $key (sort (keys (%types))) {
+
+       $lasttype = $type = $key;
+       while ($type && ($types{$type} !~ /struct/)) {
+               $lasttype = $type;
+               $type = $types{$type};
+       }
+
+       if ($types{$type} =~ /struct\s+(\w+)/) {
+               $type = $1;
+               if (exists($sdefs{$type})) {
+                       $def = $sdefs{$type};
+               } else {
+                       $def = "privatestruct";
+               }
+       } elsif ($types{$type} =~ /struct/ && $type =~ /^$ns/) {
+               $def = $types{$type};
+       } else {
+               #how to represent aliases in gidl?
+               #$elem = addNameElem($ns_elem, 'alias', $key, $ns);
+               #$elem->setAttribute('type', $lasttype);
+               #warn "alias $key to $lasttype\n" if $debug;
+               next;
+       }
+
+       # fixme: hack
+       if ($key eq "GdkBitmap") {
+               $struct_el = addNameElem($ns_elem, 'object', $key, $ns);
+       } elsif (exists($boxdefs{$key})) {
+               $struct_el = addNameElem($ns_elem, 'boxed', $key, $ns);
+       } else {
+               $struct_el = addNameElem($ns_elem, 'struct', $key, $ns);
+       }
+
+       $struct_el->setAttribute("get-type", "");
+
+       if ($def =~ /^deprecated/) {
+               $struct_el->setAttribute("deprecated", "1");
+               $def =~ s/deprecated//g;
+       }
+
+       $elem_table{lc($key)} = $struct_el;
+
+       $def =~ s/\s+/ /g;
+       if ($def =~ /privatestruct/) {
+               $struct_el->setAttribute('opaque', 'true');
+       } else {
+               $def =~ /\{(.+)\}/;
+               addFieldElems($struct_el, 'public', split(/;/, $1));
+       }
+}
+
+# really, _really_ opaque structs that aren't even defined in sources. Lovely.
+foreach $key (sort (keys (%ptrs))) {
+       next if $ptrs{$key} !~ /struct\s+(\w+)/;
+       $type = $1;
+       $struct_el = addNameElem ($ns_elem, 'struct', $key, $ns);
+       $struct_el->setAttribute('opaque', 'true');
+       $elem_table{lc($key)} = $struct_el;
+}
+
+addFuncElems();
+addStaticFuncElems();
+
+# This should probably be done in a more generic way
+foreach $define (sort (keys (%defines))) {
+       next if $define !~ /[A-Z]_STOCK_/;
+       $string_el = addNameElem ($ns_elem, "constant", $define);
+       $string_el->setAttribute('name', $define);
+       $string_el->setAttribute('type', "utf8");
+       $string_el->setAttribute('value', $defines{$define});
+}
+
+##############################################################
+# Output the tree
+##############################################################
+
+if ($ARGV[1]) {
+       open(XMLFILE, ">$ARGV[1]") || 
+                               die "Couldn't open $ARGV[1] for writing.\n";
+       print XMLFILE $doc->toString();
+       close(XMLFILE);
+} else {
+       print $doc->toString();
+}
+
+##############################################################
+# Generate a few stats from the parsed source.
+##############################################################
+
+$scnt = keys(%sdefs); $fcnt = keys(%fdefs); $tcnt = keys(%types);
+print "structs: $scnt  enums: $ecnt  callbacks: $cbcnt\n";
+print "funcs: $fcnt types: $tcnt  classes: $classcnt\n";
+print "props: $propcnt childprops: $childpropcnt signals: $sigcnt\n\n";
+
+sub addFieldElems
+{
+       my ($parent, $defaultaccess, @fields) = @_;
+       my $access = $defaultaccess;
+
+       foreach $field (@fields) {
+               if ($field =~ m!/\*< (public|private) >.*\*/(.*)$!) {
+                       $access = $1;
+                       $field = $2;
+               }
+               next if ($field !~ /\S/);
+               $field =~ s/\s+(\*+)/\1 /g;
+               $field =~ s/(const\s+)?(\w+)\*\s+const\*/const \2\*/g;
+               $field =~ s/(\w+)\s+const\s*\*/const \1\*/g;
+               $field =~ s/const /const\-/g;
+               $field =~ s/struct /struct\-/g;
+               $field =~ s/.*\*\///g;
+               next if ($field !~ /\S/);
+               
+               if ($field =~ /(\S+\s+\*?)\(\*\s*(.+)\)\s*\((.*)\)/) {
+                       # FIXME: how to handle function pointer fields with
+                       # anonymous type?
+                       #$elem = addNameElem($parent, 'callback', $2);
+                       #addReturnElem($elem, $1);
+                       #addParamsElem($elem, $3);
+               } elsif ($field =~ /(unsigned )?(\S+)\s+(.+)/) {
+                       my $type = $1 . $2; $symb = $3;
+                       foreach $tok (split (/,\s*/, $symb)) {
+                               if ($tok =~ /(\w+)\s*\[(.*)\]/) {
+                                       $elem = addFNameElem($parent, 'field', $1, "");
+                                       #$elem->setAttribute('array_len', "$2");
+                               } elsif ($tok =~ /(\w+)\s*\:\s*(\d+)/) {
+                                       $elem = addFNameElem($parent, 'field', $1, "");
+                                       #$elem->setAttribute('bits', "$2");
+                               } else {
+                                       $elem = addFNameElem($parent, 'field', $tok, "");
+                               }
+                               $elem->setAttribute('type', "$type");
+
+                               if ($access eq "public") {
+                                       $elem->setAttribute("readable", "1");
+                                       $elem->setAttribute("writable", "1");
+                               }
+                       }
+               } else {
+                       die "$field\n";
+               }
+       }
+}
+
+sub addFuncElems
+{
+       my ($obj_el, $inst, $prefix);
+
+       $fcnt = keys(%fdefs);
+
+       foreach $mname (sort (keys (%fdefs))) {
+               next if ($mname =~ /^_/);
+               $obj_el = "";
+               $prefix = $mname;
+               $prepend = undef;
+               while ($prefix =~ /(\w+)_/) {
+                       $prefix = $key = $1;
+                       $key =~ s/_//g;
+                       # FIXME: lame Gdk API hack
+                       if ($key eq "gdkdraw") {
+                               $key = "gdkdrawable";
+                               $prepend = "draw_";
+                       }
+                       if (exists ($elem_table{$key})) {
+                               $prefix .= "_";
+                               $obj_el = $elem_table{$key};
+                               $inst = $key;
+                               last;
+                       } elsif (exists ($enums{$key}) && ($mname =~ /_get_type/)) {
+                               delete $fdefs{$mname};
+                               last;
+                       }
+               }
+               next if (!$obj_el);
+
+               $mdef = delete $fdefs{$mname};
+               
+               # FIXME: gidl doesn't support constructors in structs, a bug?
+               if ($mname =~ /$prefix(new)/ && $obj_el->nodeName eq "object") {
+                       $el = addMNameElem($obj_el, 'constructor', $mname, $prefix);
+                       if ($mdef =~ /^deprecated/) {
+                               $el->setAttribute("deprecated", "1");
+                               $mdef =~ s/deprecated//g;
+                       }
+                       $drop_1st = 0;
+               } else {
+                       $el = addMNameElem($obj_el, 'method', $mname, $prefix, $prepend);
+                       if ($mdef =~ /^deprecated/) {
+                               $el->setAttribute("deprecated", "1");
+                               $mdef =~ s/deprecated//g;
+                       }
+                       $mdef =~ /(.*?)\w+\s*\(/;
+                       addReturnElem($el, $1);
+                       $mdef =~ /\(\s*(const)?\s*(\w+)/;
+                       # FIXME: gidl doesn't distinguish between static and instance methods
+                       # if (lc($2) ne $inst) {
+                       #       $el->setAttribute("shared", "true");
+                       #       $drop_1st = 0;
+                       # } else {
+                       #       $drop_1st = 1;
+                       # }
+               }
+
+               parseParms ($el, $mdef, $drop_1st);
+
+               # Don't add "free" to this regexp; that will wrongly catch all boxed types
+               if ($mname =~ /$prefix(new|destroy|ref|unref)/ &&
+                   ($obj_el->nodeName eq "boxed" || $obj_el->nodeName eq "struct") &&
+                   $obj_el->getAttribute("opaque") ne "true") {
+                       $obj_el->setAttribute("opaque", "true");
+                       for my $field ($obj_el->getElementsByTagName("field")) {
+                               if (!$field->getAttribute("access")) {
+                                       $field->setAttribute("access", "public");
+                                       $field->setAttribute("writeable", "true");
+                               }
+                       }
+               }
+       }
+}
+
+sub parseParms
+{
+       my ($el, $mdef, $drop_1st) = @_;
+
+       $fmt_args = 0;
+
+       if ($mdef =~ /G_GNUC_PRINTF.*\((\d+,\s*\d+)\s*\)/) {
+               $fmt_args = $1;
+               $mdef =~ s/\s*G_GNUC_PRINTF.*\)//;
+       }
+
+       if (($mdef =~ /\((.*)\)/) && ($1 ne "void")) {
+               @parms = ();
+               $parm = "";
+               $pcnt = 0;
+               foreach $char (split(//, $1)) {
+                       if ($char eq "(") {
+                               $pcnt++;
+                       } elsif ($char eq ")") {
+                               $pcnt--;
+                       } elsif (($pcnt == 0) && ($char eq ",")) {
+                               @parms = (@parms, $parm);
+                               $parm = "";
+                               next;
+                       }
+                       $parm .= $char;
+               }
+
+               if ($parm) {
+                       @parms = (@parms, $parm);
+               }
+               # @parms = split(/,/, $1);
+               ($dump, @parms) = @parms if $drop_1st;
+               if (@parms > 0) {
+                       addParamsElem($el, @parms);
+               }
+
+               if ($fmt_args != 0) {
+                       $fmt_args =~ /(\d+),\s*(\d+)/;
+                       $fmt = $1; $args = $2;
+                       ($params_el, @junk) = $el->getElementsByTagName ("parameters");
+                       (@params) = $params_el->getElementsByTagName ("parameter");
+                       $offset = 1 + $drop_1st;
+               }
+       }
+}
+
+sub addStaticFuncElems
+{
+       my ($global_el, $ns_prefix);
+
+       @mnames = sort (keys (%fdefs));
+       $mcount = @mnames;
+
+       return if ($mcount == 0);
+
+       $ns_prefix = "";
+       $global_el = "";
+
+       for ($i = 0; $i < $mcount; $i++) {
+               $mname = $mnames[$i];
+               $prefix = $mname;
+               next if ($prefix =~ /^_/);
+
+               if ($ns_prefix eq "") {
+                       my (@toks) = split(/_/, $prefix);
+                       for ($j = 0; $j < @toks; $j++) {
+                               if (join ("", @toks[0 .. $j]) eq lc($ns)) {
+                                       $ns_prefix = join ("_", @toks[0 .. $j]);
+                                       last;
+                               }
+                       }
+                       next if ($ns_prefix eq "");
+               }
+               next if ($mname !~ /^$ns_prefix/);
+
+               if ($mname =~ /($ns_prefix)_([a-zA-Z]+)_\w+/) {
+                       $classname = $2;
+                       $key = $prefix = $1 . "_" . $2 . "_";
+                       $key =~ s/_//g;
+                       $cnt = 1;
+                       if (exists ($enums{$key})) {
+                               $cnt = 1; 
+                       } elsif ($classname ne "set" && $classname ne "get" &&
+                           $classname ne "scan" && $classname ne "find" &&
+                           $classname ne "add" && $classname ne "remove" &&
+                           $classname ne "free" && $classname ne "register" &&
+                           $classname ne "execute" && $classname ne "show" &&
+                           $classname ne "parse" && $classname ne "paint" &&
+                           $classname ne "string") {
+                               while ($mnames[$i+$cnt] =~ /$prefix/) { $cnt++; }
+                       }
+                       if ($cnt == 1) {
+                               $mdef = delete $fdefs{$mname};
+                               
+                               if (!$global_el) {
+                                       $global_el = $doc->createElement('struct');
+                                       $global_el->setAttribute('name', "Global");
+                                       $global_el->setAttribute('cname', $ns . "Global");
+                                       $ns_elem->appendChild($global_el);
+                               }
+                               $el = addMNameElem($global_el, 'method', $mname, $ns_prefix);
+                               if ($mdef =~ /^deprecated/) {
+                                       $el->setAttribute("deprecated", "1");
+                                       $mdef =~ s/deprecated//g;
+                               }
+                               $mdef =~ /(.*?)\w+\s*\(/;
+                               addReturnElem($el, $1);
+                               #$el->setAttribute("shared", "true");
+                               parseParms ($el, $mdef, 0);
+                               next;
+                       } else {
+                               my $stname = $prefix;
+                               $stname =~ s/_$//;
+                               
+                               $class_el = $doc->createElement('struct');
+                               $class_el->setAttribute('name', StudlyCaps($stname));
+                               $ns_elem->appendChild($class_el);
+
+                               for ($j = 0; $j < $cnt; $j++) {
+                                       $mdef = delete $fdefs{$mnames[$i+$j]};
+                                       
+                                       $el = addMNameElem($class_el, 'method', $mnames[$i+$j], $prefix);
+                                       if ($mdef =~ /^deprecated/) {
+                                               $el->setAttribute("deprecated", "1");
+                                               $mdef =~ s/deprecated//g;
+                                       }
+                                       $mdef =~ /(.*?)\w+\s*\(/;
+                                       addReturnElem($el, $1);
+                                       #$el->setAttribute("shared", "true");
+                                       parseParms ($el, $mdef, 0);
+                               }
+                               $i += ($cnt - 1);
+                               next;
+                       }
+               }
+       }
+}
+
+sub addNameElem
+{
+       my ($node, $type, $cname, $prefix, $prepend) = @_;
+
+       my $elem = $doc->createElement($type);
+       $node->appendChild($elem);
+       if ($cname) {
+               $elem->setAttribute('name', $cname);
+               $elem->setAttribute('type-name', $cname);
+       }
+       return $elem;
+}
+
+sub addFNameElem
+{
+       my ($node, $type, $cname, $prefix, $prepend) = @_;
+
+       my $elem = $doc->createElement($type);
+       $node->appendChild($elem);
+       if (defined $prefix) {
+               my $match;
+               if ($cname =~ /$prefix(\w+)/) {
+                       $match = $1;
+               } else {
+                       $match = $cname;
+               }
+               if ($prepend) {
+                       $name = $prepend . $match;
+               } else {
+                       $name = $match;
+               }
+               $elem->setAttribute('name', $name);
+       }
+       return $elem;
+}
+
+sub addMNameElem
+{
+       my ($node, $type, $cname, $prefix, $prepend) = @_;
+
+       my $elem = $doc->createElement($type);
+       $node->appendChild($elem);
+       if (defined $prefix) {
+               my $match;
+               if ($cname =~ /$prefix(\w+)/) {
+                       $match = $1;
+               } else {
+                       $match = $cname;
+               }
+               if ($prepend) {
+                       $name = $prepend . $match;
+               } else {
+                       $name = $match;
+               }
+               $elem->setAttribute('name', $name);
+       }
+       if ($cname) {
+               $elem->setAttribute('symbol', $cname);
+       }
+       return $elem;
+}
+
+sub addParamsElem
+{
+       my ($parent, @params) = @_;
+
+       my $parms_elem = $doc->createElement('parameters');
+       $parent->appendChild($parms_elem);
+       my $parm_num = 0;
+       foreach $parm (@params) {
+               $parm_num++;
+               $parm =~ s/\s+(\*+)/\1 /g;
+               my $out = $parm =~ s/G_CONST_RETURN/const/g;
+               $parm =~ s/(const\s+)?(\w+)\*\s+const\*/const \2\*/g;
+               $parm =~ s/(\*+)\s*const\s+/\1 /g;
+               $parm =~ s/(\w+)\s+const\s*\*/const \1\*/g;
+               $parm =~ s/const\s+/const-/g;
+               $parm =~ s/unsigned\s+/unsigned-/g;
+               if ($parm =~ /(.*)\(\s*\**\s*(\w+)\)\s+\((.*)\)/) {
+                       my $ret = $1; my $cbn = $2; my $params = $3;
+                       my $type = $parent->getAttribute('name') . StudlyCaps($cbn);
+                       $cb_elem = addNameElem($ns_elem, 'callback', $type, $ns);
+                       addReturnElem($cb_elem, $ret);
+                       if ($params && ($params ne "void")) {
+                               addParamsElem($cb_elem, split(/,/, $params));
+                               my $data_parm = $cb_elem->lastChild()->lastChild();
+                               if ($data_parm && $data_parm->getAttribute('type') eq "gpointer") {
+                                   $data_parm->setAttribute('name', 'data');
+                               }
+                       }
+                       $parm_elem = $doc->createElement('parameter');
+                       $parm_elem->setAttribute('type', $type);
+                       $parm_elem->setAttribute('name', $cbn);
+                       $parms_elem->appendChild($parm_elem);
+                       next;
+               } elsif ($parm =~ /\.\.\./) {
+                       # FIXME: GIDL doesn't seem to support ellipsis parameters yet
+                       # $parm_elem = $doc->createElement('parameter');
+                       # $parms_elem->appendChild($parm_elem);
+                       # $parm_elem->setAttribute('ellipsis', 'true');
+                       next;
+               }
+               $parm_elem = $doc->createElement('parameter');
+               $parms_elem->appendChild($parm_elem);
+               my $name = "";
+               if ($parm =~ /struct\s+(\S+)\s+(\S+)/) {
+                       $parm_elem->setAttribute('type', $1);
+                       $name = $2;
+               }elsif ($parm =~ /(unsigned )?(\S+)\s+(\S+)/) {
+                       $parm_elem->setAttribute('type', $1 . $2);
+                       $name = $3;
+               } elsif ($parm =~ /(\S+)/) {
+                       $parm_elem->setAttribute('type', $1);
+                       $name = "arg" . $parm_num;
+               }
+               if ($name =~ /(\w+)\[.*\]/) {
+                       $name = $1;
+                       $parm_elem->setAttribute('type', $parm_elem->getAttribute('type') . '[]');
+               }
+               if ($out) {
+                       $parm_elem->setAttribute('direction', "out");
+               }
+               $parm_elem->setAttribute('name', $name);
+       }
+}
+
+sub addReturnElem
+{
+       my ($parent, $ret) = @_;
+
+       $ret =~ s/(\w+)\s+const\s*\*/const \1\*/g;
+       $ret =~ s/const|G_CONST_RETURN/const-/g;
+       $ret =~ s/\s+//g;
+       $ret =~ s/(const-)?(\w+)\*(const-)\*/const-\2\*\*/g;
+       my $ret_elem = $doc->createElement('return-type');
+       $parent->appendChild($ret_elem);
+       $ret_elem->setAttribute('type', $ret);
+       return $ret_elem;
+}
+
+sub addPropElem
+{
+       my ($spec, $node, $is_child) = @_;
+       my ($name, $mode, $docs);
+       $spec =~ /g_param_spec_(\w+)\s*\((.*)\s*\)\s*\)/;
+       my $type = $1;
+       my @params = split(/,/, $2);
+
+       $name = $params[0];
+       if ($defines{$name}) {
+               $name = $defines{$name};
+       } else {
+               $name =~ s/\s*\"//g;
+       }
+
+       $mode = $params[$#params];
+
+       if ($type =~ /boolean|float|double|^u?int|pointer|unichar/) {
+               $type = "g$type";
+       } elsif ($type =~ /string/) {
+               $type = "gchar*";
+       } elsif ($type =~ /boxed|object/) {
+               $type = $params[$#params-1];
+               $type =~ s/TYPE_//;
+               $type =~ s/\s+//g;
+               $type = StudlyCaps(lc($type));
+       } elsif ($type =~ /enum|flags/) {
+               $type = $params[$#params-2];
+               $type =~ s/TYPE_//;
+               $type =~ s/\s+//g;
+               $type = StudlyCaps(lc($type));
+       }
+
+       $prop_elem = $doc->createElement($is_child ? "childprop" : "property");
+       $node->appendChild($prop_elem);
+       $prop_elem->setAttribute('name', $name);
+
+       $prop_elem->setAttribute('readable', "1") if ($mode =~ /READ/);
+       $prop_elem->setAttribute('writable', "1") if ($mode =~ /WRIT/);
+       $prop_elem->setAttribute('construct', "1") if ($mode =~ /CONSTRUCT(?!_)/);
+       $prop_elem->setAttribute('construct-only', "1") if ($mode =~ /CONSTRUCT_ONLY/);
+
+       $prop_elem->setAttribute('type', $type);
+}
+
+sub parseTypeToken
+{
+       my ($tok) = @_;
+
+       if ($tok =~ /G_TYPE_(\w+)/) {
+               my $type = $1;
+               if ($type eq "NONE") {
+                       return "void";
+               } elsif ($type eq "INT") {
+                       return "gint32";
+               } elsif ($type eq "UINT") {
+                       return "guint32";
+               } elsif ($type eq "ENUM" || $type eq "FLAGS") {
+                       return "gint32";
+               } elsif ($type eq "STRING") {
+                       return "gchar*";
+               } elsif ($type eq "OBJECT") {
+                       return "GObject*";
+               } else {
+                       return "g" . lc ($type);
+               }
+       } else {
+               $tok =~ s/_TYPE//; 
+               $tok =~ s/\|.*STATIC_SCOPE//; 
+               $tok =~ s/\W+//g;
+               return StudlyCaps (lc($tok));
+       }
+}
+
+sub addSignalElem
+{
+       my ($spec, $class, $node) = @_;
+       $spec =~ s/\n\s*//g; $class =~ s/\n\s*//g;
+
+       $sig_elem = $doc->createElement('signal');
+       $node->appendChild($sig_elem);
+
+       if ($spec =~ /\(\"([\w\-]+)\"/) {
+               my $cname = $1;
+               $cname =~ s/-/_/g;
+               $sig_elem->setAttribute('name', $cname);
+       }
+       if ($spec =~ /_RUN_(\w+)/) {
+               $sig_elem->setAttribute('when', $1);
+       } else {
+               $sig_elem->setAttribute('when', "LAST");
+       }
+
+       my $method = "";
+       if ($spec =~ /_OFFSET\s*\(\w+,\s*(\w+)\)/) {
+               $method = $1;
+       } else {
+               @args = split(/,/, $spec);
+               my $rettype = parseTypeToken ($args[7]);
+               addReturnElem($sig_elem, $rettype);
+               $parmcnt = $args[8];
+               $parmcnt =~ s/.*(\d+).*/\1/;
+               $parms_elem = $doc->createElement('parameters');
+               $sig_elem->appendChild($parms_elem);
+               $parm_elem = $doc->createElement('parameter');
+               $parms_elem->appendChild($parm_elem);
+               $parm_elem->setAttribute('name', "inst");
+               $parm_elem->setAttribute('type', "$inst*");
+               for (my $idx = 0; $idx < $parmcnt; $idx++) {
+                       my $argtype = parseTypeToken ($args[9+$idx]);
+                       $parm_elem = $doc->createElement('parameter');
+                       $parms_elem->appendChild($parm_elem);
+                       $parm_elem->setAttribute('name', "p$idx");
+                       $parm_elem->setAttribute('type', $argtype);
+               }
+               return $class;
+       }
+
+       if ($class =~ /;\s*(\/\*< public >\*\/)?(G_CONST_RETURN\s+)?(\w+\s*\**)\s*\(\s*\*\s*$method\)\s*\((.*?)\);/) {
+               $ret = $3; $parms = $4;
+               addReturnElem($sig_elem, $ret);
+               if ($parms && ($parms ne "void")) {
+                       addParamsElem($sig_elem, split(/,/, $parms));
+               }
+               $class =~ s/;\s*(\/\*< public >\*\/)?(G_CONST_RETURN\s+)?\w+\s*\**\s*\(\s*\*\s*$method\)\s*\(.*?\);/;/;
+       } else {
+               #die "$method $class";
+               return $class;
+       }
+
+       return $class;
+}
+
+sub addVirtualMethods
+{
+       my ($class, $node) = @_;
+       $class =~ s/\n\s*//g;
+       $class =~ s/\/\*.*?\*\///g;
+
+       while ($class =~ /;\s*(G_CONST_RETURN\s+)?(\S+\s*\**)\s*\(\s*\*\s*(\w+)\)\s*\((.*?)\);/) {
+               $ret = $1 . $2; $cname = $3; $parms = $4;
+               if ($cname !~ /reserved/) {
+                       $vm_elem = $doc->createElement('vfunc');
+                       $node->appendChild($vm_elem);
+                       $vm_elem->setAttribute('name', $cname);
+                       addReturnElem($vm_elem, $ret);
+                       if ($parms && ($parms ne "void")) {
+                               addParamsElem($vm_elem, split(/,/, $parms));
+                       }
+               }
+               $class =~ s/;\s*(G_CONST_RETURN\s+)?\S+\s*\**\s*\(\s*\*\s*\w+\)\s*\(.*?\);/;/;
+       }
+}
+
+sub addImplementsElem
+{
+       my ($spec, $node) = @_;
+       $spec =~ s/\n\s*//g; 
+       if ($spec =~ /,\s*(\w+)_TYPE_(\w+),/) {
+               $impl_elem = $doc->createElement('interface');
+               $name = StudlyCaps (lc ("$1_$2"));
+               $impl_elem->setAttribute ("name", "$name");
+               $node->appendChild($impl_elem);
+       }
+}
+
+
+sub parseInitFunc
+{
+       my ($obj_el, $initfunc) = @_;
+
+       my @init_lines = split (/\n/, $initfunc);
+
+       my $linenum = 0;
+       while ($linenum < @init_lines) {
+
+               my $line = $init_lines[$linenum];
+                       
+               if ($line =~ /#define/) {
+                       # FIXME: This ignores the bool helper macro thingie.
+               } elsif ($line =~ /g_object_(class|interface)_install_prop/) {
+                       my $prop = $line;
+                       do {
+                               $prop .= $init_lines[++$linenum];
+                       } until ($init_lines[$linenum] =~ /\)\s*;/);
+                       addPropElem ($prop, $obj_el, 0);
+                       $propcnt++;
+               # FIXME: how to handle childprops in GIDL?
+               #} elsif ($line =~ /gtk_container_class_install_child_property/) {
+               #       my $prop = $line;
+               #       do {
+               #               $prop .= $init_lines[++$linenum];
+               #       } until ($init_lines[$linenum] =~ /\)\s*;/);
+               #       addPropElem ($prop, $obj_el, 1);
+               #       $childpropcnt++;
+               } elsif ($line =~ /\bg.*_signal_new/) {
+                       my $sig = $line;
+                       do {
+                               $sig .= $init_lines[++$linenum];
+                       } until ($init_lines[$linenum] =~ /;/);
+                       $classdef = addSignalElem ($sig, $classdef, $obj_el);
+                       $sigcnt++;
+               }
+               $linenum++;
+       }
+
+       addVirtualMethods ($classdef, $obj_el);
+}
+
+sub parseTypeFuncMacro
+{
+       my ($obj_el, $typefunc) = @_;
+
+       $impls_node = undef;
+       while ($typefunc =~ /G_IMPLEMENT_INTERFACE\s*\(\s*(\w+)/) {
+               $iface = $1;
+               if (not $impls_node) {
+                       $impls_node = $doc->createElement ("implements");
+                       $obj_el->appendChild ($impls_node);
+               }
+               addImplementsElem ($prop, $impl_node);
+               if ($iface =~ /(\w+)_TYPE_(\w+)/) {
+                       $impl_elem = $doc->createElement('interface');
+                       $name = StudlyCaps (lc ("$1_$2"));
+                       $impl_elem->setAttribute ("name", "$name");
+                       if ($name !~ /GtkFileChooserEmbed/) {
+                               $impls_node->appendChild($impl_elem);
+                       }
+               }
+               $typefunc =~ s/G_IMPLEMENT_INTERFACE\s*\(.*?\)//;
+       }
+}
+
+sub parseTypeFunc
+{
+       my ($obj_el, $typefunc) = @_;
+
+       my @type_lines = split (/\n/, $typefunc);
+
+       my $linenum = 0;
+       $impl_node = undef;
+       while ($linenum < @type_lines) {
+
+               my $line = $type_lines[$linenum];
+                       
+               if ($line =~ /#define/) {
+                       # FIXME: This ignores the bool helper macro thingie.
+               } elsif ($line =~ /g_type_add_interface_static/) {
+                       my $prop = $line;
+                       do {
+                               $prop .= $type_lines[++$linenum];
+                       } until ($type_lines[$linenum] =~ /;/);
+                       if (not $impl_node) {
+                               $impl_node = $doc->createElement ("implements");
+                               $obj_el->appendChild ($impl_node);
+                       }
+                       addImplementsElem ($prop, $impl_node);
+               }
+               $linenum++;
+       }
+}
+
+##############################################################
+# Converts a dash or underscore separated name to StudlyCaps.
+##############################################################
+
+%num2txt = ('1', "One", '2', "Two", '3', "Three", '4', "Four", '5', "Five",
+           '6', "Six", '7', "Seven", '8', "Eight", '9', "Nine", '0', "Zero");
+
+sub StudlyCaps
+{
+       my ($symb) = @_;
+       $symb =~ s/^([a-z])/\u\1/;
+       $symb =~ s/^(\d)/\1_/;
+       $symb =~ s/[-_]([a-z])/\u\1/g;
+       $symb =~ s/[-_](\d)/\1/g;
+       $symb =~ s/^2/Two/;
+       $symb =~ s/^3/Three/;
+       return $symb;
+}
+

diff --git a/vapigen/gidlgen/gapi_pp.pl b/vapigen/gidlgen/gapi_pp.pl
new file mode 100755 (executable)
index 0000000..fcfe0ac
--- /dev/null
+++ b/vapigen/gidlgen/gapi_pp.pl
@@ -0,0 +1,257 @@
+#!/usr/bin/perl
+#
+# gapi_pp.pl : A source preprocessor for the extraction of API info from a
+#             C library source directory.
+#
+# Authors: Mike Kestner <mkestner@speakeasy.net>
+#         Martin Willemoes Hansen <mwh@sysrq.dk>
+#
+# Copyright (c) 2001 Mike Kestner
+# Copyright (c) 2003 Martin Willemoes Hansen
+# Copyright (c) 2003-2004 Novell, Inc.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 2 of the GNU General Public
+# License as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+$private_regex = '^#if.*(ENABLE_BACKEND|ENABLE_ENGINE)';
+$eatit_regex = '^#if(.*(__cplusplus|DEBUG|DISABLE_COMPAT|ENABLE_BROKEN)|\s+0\s*$)';
+$ignoreit_regex = '^\s+\*|#ident|#error|#\s*include|#\s*else|#\s*undef|G_(BEGIN|END)_DECLS|GDKVAR|GTKVAR|GTKMAIN_C_VAR|GTKTYPEUTILS_VAR|VARIABLE|GTKTYPEBUILTIN';
+
+foreach $arg (@ARGV) {
+       if (-d $arg && -e $arg) {
+               @hdrs = (@hdrs, `ls $arg/*.h`);
+               @srcs = (@srcs, `ls $arg/*.c`);
+       } elsif (-f $arg && -e $arg) {
+               @hdrs = (@hdrs, $arg) if ($arg =~ /\.h$/);
+               @srcs = (@srcs, $arg) if ($arg =~ /\.c$/);
+       } else {
+               die "unable to process arg: $arg";
+       }
+}
+
+foreach $fname (@hdrs) {
+
+       if ($fname =~ /test|private|internals|gtktextlayout|gtkmarshalers/) {
+               @privhdrs = (@privhdrs, $fname);
+               next;
+       }
+
+       open(INFILE, $fname) || die "Could open $fname\n";
+
+       $braces = 0;
+       $deprecated = -1;
+       $ifdeflevel = 0;
+       $prepend = "";
+       while ($line = <INFILE>) {
+               $braces++ if ($line =~ /{/ and $line !~ /}/);
+               $braces-- if ($line =~ /}/ and $line !~ /{/);
+               
+               next if ($line =~ /$ignoreit_regex/);
+
+               $line =~ s/\/\*[^<].*?\*\///g;
+               
+               next if ($line !~ /\S/);
+
+               $line = $prepend . $line;
+               $prepend = "";
+
+               if ($line =~ /#\s*define\s+\w+\s+\"/) {
+                       $def = $line;
+                       while ($def !~ /\".*\"/) {$def .= ($line = <INFILE>);}
+                       print $def;
+               } elsif ($line =~ /#\s*define\s+\w+\s*\D+/) {
+                       $def = $line;
+                       while ($line =~ /\\\n/) {$def .= ($line = <INFILE>);}
+                       if ($def =~ /_CHECK_\w*CAST|INSTANCE_GET_INTERFACE/) {
+                               $def =~ s/\\\n//g;
+                               print $def;
+                       }
+               } elsif ($line =~ /^\s*\/\*[^<]/) {
+                       while ($line !~ /\*\//) {$line = <INFILE>;}
+               } elsif ($line =~ /^extern/) {
+                       while ($line !~ /;/) {$line = <INFILE>;}
+               } elsif ($line =~ /^#ifndef\s+\w+_H_*\b/) {
+                       while ($line !~ /#define/) {$line = <INFILE>;}
+               } elsif ($line =~ /$private_regex/) {
+                       $nested = 0;
+                       while ($line = <INFILE>) {
+                               last if (!$nested && ($line =~ /#else|#endif/));
+                               if ($line =~ /#if/) {
+                                       $nested++;
+                               } elsif ($line =~ /#endif/) {
+                                       $nested--
+                               }
+                               next if ($line !~ /^struct/);
+
+                               print "private$line";
+                               do {
+                                       $line = <INFILE>;
+                                       print $line;
+                               } until ($line =~ /^\}/);
+                       }
+               } elsif ($line =~ /$eatit_regex/) {
+                       $nested = 0;
+                       while ($line = <INFILE>) {
+                               last if (!$nested && ($line =~ /#else|#endif/));
+                               if ($line =~ /#if/) {
+                                       $nested++;
+                               } elsif ($line =~ /#endif/) {
+                                       $nested--
+                               }
+                       }
+               } elsif ($line =~ /^#\s*ifn?\s*\!?def/) {
+                       $ifdeflevel++;
+                       #print "#ifn?def ($ifdeflevel): $line\n";
+                       if ($line =~ /#ifndef.*DISABLE_DEPRECATED/) {
+                               $deprecated = $ifdeflevel;
+                       } elsif ($line =~ /#if !defined.*DISABLE_DEPRECATED/) {
+                               $deprecated = $ifdeflevel;
+                       }
+               } elsif ($line =~ /^#\s*endif/) {
+                       #print "#endif   ($ifdeflevel): $line\n";
+                       if ($deprecated == $ifdeflevel) {
+                               $deprecated = -1;
+                       }
+                       $ifdeflevel--;
+               } elsif ($line =~ /typedef struct\s*\{/) {
+                       my $first_line = $line;
+                       my @lines = ();
+                       $line = <INFILE>;
+                       while ($line !~ /^}\s*(\w+);/) {
+                               push @lines, $line;
+                               $line = <INFILE>;
+                       }
+                       $line =~ /^}\s*(\w+);/;
+                       my $name = $1;
+                       print "typedef struct _$name $name;\n";
+                       print "struct _$name {\n";
+                       foreach $line (@lines) {
+                               if ($line =~ /(\s*.+\;)/) {
+                                       $field = $1;
+                                       $field =~ s/(\w+) const/const $1/;
+                                       print "$field\n";
+                               }
+                       }
+                       print "};\n";
+               } elsif ($line =~ /^enum\s+\{/) {
+                       while ($line !~ /^};/) {$line = <INFILE>;}
+               } elsif ($line =~ /^(typedef\s+)?union/) {
+                       next if ($line =~ /^typedef\s+union\s+\w+\s+\w+;/);
+                       while ($line !~ /^};/) {$line = <INFILE>;}
+               } elsif ($line =~ /(\s+)union\s*{/) {
+                       # this is a hack for now, but I need it for the fields to work
+                       $indent = $1;
+                       $do_print = 1;
+                       while ($line !~ /^$indent}\s*\w+;/) {
+                               $line = <INFILE>;
+                               next if ($line !~ /;/);
+                               print $line if $do_print;
+                               $do_print = 0;
+                       }
+               } else {
+                       if ($braces or $line =~ /;|\/\*/) {
+                               if ($deprecated == -1) {
+                                       print $line;
+                               } else {
+                                       print "deprecated$line";
+                               }
+                       } else {
+                               $prepend = $line;
+                               $prepend =~ s/\n/ /g;
+                       }
+               }
+       }
+}
+
+foreach $fname (@srcs, @privhdrs) {
+
+       open(INFILE, $fname) || die "Could open $fname\n";
+
+       if ($fname =~ /builtins_ids/) {
+               while ($line = <INFILE>) {
+                       next if ($line !~ /\{/);
+
+                       chomp($line);
+                       $builtin = "BUILTIN" . $line;
+                       $builtin .= <INFILE>;
+                       print $builtin;
+               }
+               next;
+       }
+
+       while ($line = <INFILE>) {
+               next if ($line !~ /^(struct|\w+_class_init|\w+_base_init|\w+_get_type\b|G_DEFINE_TYPE_WITH_CODE)/);
+
+               if ($line =~ /^G_DEFINE_TYPE_WITH_CODE/) {
+                       my $macro;
+                       my $parens = 0;
+                       do {
+                               chomp ($line);
+                               $line =~ s/(.*)\\$/\1/;
+                               $line =~ s/^\s+(.*)/ \1/;
+                               $macro .= $line;
+                               foreach $chr (split (//, $line)) {
+                                       if ($chr eq "(") {
+                                               $parens++;
+                                       } elsif ($chr eq ")") {
+                                               $parens--;
+                                       }
+                               }
+                               $line = <INFILE>;
+                       } while ($parens > 0);
+                       print "$macro\n";
+                       next if ($line !~ /^(struct|\w+_class_init|\w+_base_init)/);
+               }
+
+               if ($line =~ /^struct/) {
+                       # need some of these to parse out parent types
+                       print "private";
+                       if ($line =~ /;/) {
+                               print $line;
+                               next;
+                       }
+               }
+
+               $comment = 0;
+               $begin = 0;
+               $end = 0;
+               do {
+                       # Following ifs strips out // and /* */ C comments
+                       if ($line =~ /\/\*/) {
+                               $comment = 1;
+                               $begin = 1;
+                       }
+
+                       if ($comment != 1) {
+                               $line =~ s/\/\/.*//;
+                               print $line;
+                       }
+
+                       if ($line =~ /\*\//) {
+                               $comment = 0;
+                               $end = 1;
+                       }
+
+                       if ($begin == 1 && $end == 1) {
+                               $line =~ s/\/\*.*\*\///;
+                               print $line;
+                       }
+
+                       $begin = 0;
+                       $end = 0;
+               } until (($line = <INFILE>) =~ /^}/);
+               print $line;
+       }
+}
+

diff --git a/vapigen/gidlgen/gidlgen b/vapigen/gidlgen/gidlgen
new file mode 100755 (executable)
index 0000000..163b61a
--- /dev/null
+++ b/vapigen/gidlgen/gidlgen
@@ -0,0 +1,35 @@
+#!/bin/sh
+
+pkglibdir=$(dirname $0)
+
+SOURCE=$1
+PKGBASE=$2
+
+if [ $# -ne 2 ]
+then
+       echo "Usage: $0 SOURCE PKGBASE"
+       exit 1
+fi
+
+EXCLUDES=
+if [ -e $PKGBASE.excludes ]
+then
+       EXCLUDES="-X $PKGBASE.excludes"
+fi
+
+rm -rf $PKGBASE-src $PKGBASE.raw
+
+mkdir -p $PKGBASE-src
+tar -C $PKGBASE-src -xf $SOURCE $EXCLUDES --strip-components=1
+
+if [ -e $PKGBASE.patch ]
+then
+       # use < instead of -i to use current working directory as base
+       patch -d $PKGBASE-src -Np1 < $PKGBASE.patch
+fi
+
+perl $pkglibdir/gapi_pp.pl $(cat $PKGBASE.files | sed -e "s@^@$PKGBASE-src/@") | perl $pkglibdir/gapi2xml.pl $(cat $PKGBASE.namespace) $PKGBASE.raw
+
+xml_pp $PKGBASE.raw > $PKGBASE.gidl
+
+rm -rf $PKGBASE-src

diff --git a/vapigen/gobject-introspection/Makefile.am b/vapigen/gobject-introspection/Makefile.am
new file mode 100644 (file)
index 0000000..7196fe6
--- /dev/null
+++ b/vapigen/gobject-introspection/Makefile.am
@@ -0,0 +1,25 @@
+NULL =
+
+INCLUDES = \
+       $(GLIB_CFLAGS) \
+       $(NULL)
+
+noinst_LTLIBRARIES = \
+       libgidl.la \
+       $(NULL)
+
+libgidl_la_SOURCES = \
+       gidlmodule.c \
+       gidlmodule.h \
+       gidlnode.c \
+       gidlnode.h \
+       gidlparser.c \
+       gidlparser.h \
+       gmetadata.h \
+       $(NULL)
+
+libgidl_la_LIBADD = \
+       $(GLIB_LIBS) \
+       $(NULL)
+
+EXTRA_DIST = gidl.vala

diff --git a/vapigen/gobject-introspection/gidl.vala b/vapigen/gobject-introspection/gidl.vala
new file mode 100644 (file)
index 0000000..2572b32
--- /dev/null
+++ b/vapigen/gobject-introspection/gidl.vala
@@ -0,0 +1,260 @@
+/* gidl.vala
+ *
+ * Copyright (C) 2006  Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ *     Jürg Billeter <j@bitron.ch>
+ */
+
+[CCode (cprefix = "G", lower_case_cprefix = "g_", cheader_filename = "glib.h")]
+namespace GLib {
+       [CCode (cheader_filename = "gidlparser.h")]
+       public struct Idl {
+               public static ref List<IdlModule> parse_file (string! filename, out Error error);
+       }
+       
+       [CCode (cheader_filename = "gidlmodule.h")]
+       [ReferenceType (free_function = "g_idl_module_free")]
+       public struct IdlModule {
+               public string name;
+               public List<IdlNode> entries;
+       }
+
+       [CCode (cprefix = "G_IDL_NODE_", cheader_filename = "gidlnode.h")]
+       public enum IdlNodeTypeId {
+               INVALID,
+               FUNCTION,
+               CALLBACK,
+               STRUCT,
+               BOXED,
+               ENUM,
+               FLAGS,
+               OBJECT,
+               INTERFACE,
+               CONSTANT,
+               ERROR_DOMAIN,
+               UNION,
+               PARAM,
+               TYPE,
+               PROPERTY,
+               SIGNAL,
+               VALUE,
+               VFUNC,
+               FIELD,
+               XREF
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNode {
+               public IdlNodeTypeId type;
+               public string name;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeFunction {
+               public bool deprecated;
+               
+               public bool is_method;
+               public bool is_setter;
+               public bool is_getter;
+               public bool is_constructor;
+               public bool wraps_vfunc;
+               
+               public string symbol;
+               
+               public IdlNodeParam result;
+               public List<IdlNodeParam> parameters;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeSignal {
+               public bool deprecated;
+               
+               public bool run_first;
+               public bool run_last;
+               public bool run_cleanup;
+               public bool no_recurse;
+               public bool detailed;
+               public bool action;
+               public bool no_hooks;
+               
+               public bool has_class_closure;
+               public bool true_stops_emit;
+               
+               public int class_closure;
+               
+               public List<IdlNodeParam> parameters;
+               public IdlNodeParam result;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeBoxed {
+               public bool deprecated;
+               
+               public string gtype_name;
+               public string gtype_init;
+               
+               public List<IdlNode> members;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeEnum {
+               public bool deprecated;
+               
+               public string gtype_name;
+               public string gtype_init;
+               
+               public List<IdlNode> values;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeField {
+               public bool readable;
+               public bool writable;
+               public int bits;
+               public int offset;
+               
+               public IdlNodeType type;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeConstant {
+               public bool deprecated;
+               
+               public IdlNodeType type;
+               
+               public string value;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeInterface {
+               public bool deprecated;
+               
+               public string gtype_name;
+               public string gtype_init;
+               
+               public string parent;
+               
+               public List<string> interfaces;
+               public List<string> prerequisites;
+               
+               public List<IdlNode> members;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeParam {
+               public bool @in;
+               public bool @out;
+               public bool dipper;
+               public bool optional;
+               public bool retval;
+               public bool null_ok;
+               public bool transfer;
+               public bool shallow_transfer;
+               
+               public IdlNodeType type;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeProperty {
+               public bool deprecated;
+               
+               public string name;
+               
+               public bool readable;
+               public bool writable;
+               public bool @construct;
+               public bool construct_only;
+               
+               public IdlNodeType type;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeStruct {
+               public bool deprecated;
+               
+               public List<IdlNode> members;
+       }
+       
+       [CCode (cheader_filename = "gidlnode.h")]
+       [ReferenceType (free_function = "g_idl_node_free")]
+       public struct IdlNodeType {
+               public bool is_pointer;
+               public bool is_basic;
+               public bool is_array;
+               public bool is_glist;
+               public bool is_gslist;
+               public bool is_ghashtable;
+               public bool is_interface;
+               public bool is_error;
+               public TypeTag tag;
+               
+               public string unparsed;
+               
+               public bool zero_terminated;
+               public bool has_length;
+               public int length;
+               
+               public IdlNodeType parameter_type1;
+               public IdlNodeType parameter_type2;
+               
+               public string @interface;
+               public string[] errors;
+       }
+
+       [CCode (cprefix = "TYPE_TAG_", cheader_filename = "gmetadata.h")]
+       public enum TypeTag
+       {
+               VOID,
+               BOOLEAN,
+               INT8,
+               UINT8,
+               INT16,
+               UINT16,  
+               INT32,
+               UINT32,
+               INT64,
+               UINT64,
+               INT,
+               UINT,
+               LONG,
+               ULONG,
+               SSIZE,
+               SIZE,
+               FLOAT,
+               DOUBLE,
+               UTF8,
+               FILENAME,
+               ARRAY,
+               INTERFACE,
+               LIST,
+               SLIST,
+               HASH,
+               ERROR
+       }
+}

diff --git a/vapigen/gobject-introspection/gidlmodule.c b/vapigen/gobject-introspection/gidlmodule.c
new file mode 100644 (file)
index 0000000..2d4929e
--- /dev/null
+++ b/vapigen/gobject-introspection/gidlmodule.c
@@ -0,0 +1,208 @@
+/* GObject introspection: Metadata creation 
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "gidlmodule.h"
+#include "gidlnode.h"
+#include "gmetadata.h"
+
+#define ALIGN_VALUE(this, boundary) \
+  (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
+
+
+GIdlModule *
+g_idl_module_new (const gchar *name)
+{
+  GIdlModule *module;
+  
+  module = g_new (GIdlModule, 1);
+
+  module->name = g_strdup (name);
+  module->entries = NULL;
+
+  return module;
+}
+
+void
+g_idl_module_free (GIdlModule *module)
+{
+  GList *e;
+
+  g_free (module->name);
+
+  for (e = module->entries; e; e = e->next)
+    g_idl_node_free ((GIdlNode *)e->data);
+
+  g_list_free (module->entries);
+
+  g_free (module);
+}
+
+void  
+g_idl_module_build_metadata (GIdlModule  *module,
+                            GList       *modules,
+                            guchar     **metadata,
+                            gsize       *length)
+{
+  gint i;
+  GList *e;
+  Header *header;
+  DirEntry *entry;
+  guint32 header_size;
+  guint32 dir_size;
+  guint32 n_entries;
+  guint32 n_local_entries;
+  guint32 size, offset, offset2, old_offset;
+  GHashTable *strings;
+  GHashTable *types;
+  guchar *data;
+
+  header_size = ALIGN_VALUE (sizeof (Header), 4);
+  n_local_entries = g_list_length (module->entries);
+
+ restart:
+  init_stats ();
+  strings = g_hash_table_new (g_str_hash, g_str_equal);
+  types = g_hash_table_new (g_str_hash, g_str_equal);
+  n_entries = g_list_length (module->entries);
+
+  g_message ("%d entries (%d local)\n", n_entries, n_local_entries);
+  
+  dir_size = n_entries * 12;  
+  size = header_size + dir_size;
+
+  size += ALIGN_VALUE (strlen (module->name) + 1, 4);
+
+  for (e = module->entries; e; e = e->next)
+    {
+      GIdlNode *node = e->data;
+      
+      size += g_idl_node_get_full_size (node);
+    }
+
+  g_message ("allocating %d bytes (%d header, %d directory, %d entries)\n", 
+         size, header_size, dir_size, size - header_size - dir_size);
+
+  data = g_malloc0 (size);
+
+  /* fill in header */
+  header = (Header *)data;
+  memcpy (header, G_IDL_MAGIC, 16);
+  header->major_version = 1;
+  header->minor_version = 0;
+  header->reserved = 0;
+  header->n_entries = n_entries;
+  header->n_local_entries = n_local_entries;
+  header->n_annotations = 0;
+  header->annotations = 0; /* filled in later */
+  header->size = 0; /* filled in later */
+  header->namespace = write_string (module->name, strings, data, &header_size);
+  header->directory = ALIGN_VALUE (header_size, 4);
+  header->entry_blob_size = 12;
+  header->function_blob_size = 16;
+  header->callback_blob_size = 12;
+  header->signal_blob_size = 12;
+  header->vfunc_blob_size = 16;
+  header->arg_blob_size = 12;
+  header->property_blob_size = 12;
+  header->field_blob_size = 12;
+  header->value_blob_size = 12;
+  header->constant_blob_size = 20;
+  header->error_domain_blob_size = 16;
+  header->annotation_blob_size = 12;
+  header->signature_blob_size = 8;
+  header->enum_blob_size = 20;
+  header->struct_blob_size = 20;
+  header->object_blob_size = 32;
+  header->interface_blob_size = 28;
+  header->union_blob_size = 28;
+
+  /* fill in directory and content */
+  entry = (DirEntry *)&data[header->directory];
+
+  offset2 = header->directory + dir_size;
+
+  for (e = module->entries, i = 0; e; e = e->next, i++)
+    {
+      GIdlNode *node = e->data;
+
+      if (strchr (node->name, '.'))
+        {
+         g_error ("Names may not contain '.'");
+       }
+
+      /* we picked up implicit xref nodes, start over */
+      if (i == n_entries)
+       {
+         g_message ("Found implicit cross references, starting over");
+
+         g_hash_table_destroy (strings);
+         g_hash_table_destroy (types);
+         strings = NULL;
+
+         g_free (data);
+         data = NULL;
+
+         goto restart;
+       }
+       
+      offset = offset2;
+
+      if (node->type == G_IDL_NODE_XREF)
+       {
+         entry->blob_type = 0;
+         entry->local = FALSE;
+         entry->offset = write_string (((GIdlNodeXRef*)node)->namespace, strings, data, &offset2);
+         entry->name = write_string (node->name, strings, data, &offset2);
+       }
+      else
+       {
+         old_offset = offset;
+         offset2 = offset + g_idl_node_get_size (node);
+
+         entry->blob_type = node->type;
+         entry->local = TRUE;
+         entry->offset = offset;
+         entry->name = write_string (node->name, strings, data, &offset2);
+
+         g_idl_node_build_metadata (node, module, modules, 
+                                    strings, types, data, &offset, &offset2);
+
+         if (offset2 > old_offset + g_idl_node_get_full_size (node))
+           g_error ("left a hole of %d bytes\n", offset2 - old_offset - g_idl_node_get_full_size (node));
+       }
+
+      entry++;
+    }
+
+  dump_stats ();
+  g_hash_table_destroy (strings);
+  g_hash_table_destroy (types);
+
+  header->annotations = offset2;
+  
+  g_message ("reallocating to %d bytes", offset2);
+
+  *metadata = g_realloc (data, offset2);
+  *length = header->size = offset2;
+}
+

diff --git a/vapigen/gobject-introspection/gidlmodule.h b/vapigen/gobject-introspection/gidlmodule.h
new file mode 100644 (file)
index 0000000..1713576
--- /dev/null
+++ b/vapigen/gobject-introspection/gidlmodule.h
@@ -0,0 +1,47 @@
+/* GObject introspection: Parsed IDL
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_IDL_MODULE_H__
+#define __G_IDL_MODULE_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+
+typedef struct _GIdlModule GIdlModule;
+
+struct _GIdlModule
+{ 
+  gchar *name;
+  GList *entries;
+};
+
+GIdlModule *g_idl_module_new            (const gchar *name);
+void        g_idl_module_free           (GIdlModule  *module);
+
+void        g_idl_module_build_metadata (GIdlModule  *module,
+                                        GList       *modules,
+                                        guchar     **metadata,
+                                        gsize       *length);
+
+G_END_DECLS
+
+#endif  /* __G_IDL_MODULE_H__ */

diff --git a/vapigen/gobject-introspection/gidlnode.c b/vapigen/gobject-introspection/gidlnode.c
new file mode 100644 (file)
index 0000000..bbde2a0
--- /dev/null
+++ b/vapigen/gobject-introspection/gidlnode.c
@@ -0,0 +1,1992 @@
+/* GObject introspection: Metadata creation
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "gidlmodule.h"
+#include "gidlnode.h"
+#include "gmetadata.h"
+
+static gulong string_count = 0;
+static gulong unique_string_count = 0;
+static gulong string_size = 0;
+static gulong unique_string_size = 0;
+static gulong types_count = 0;
+static gulong unique_types_count = 0;
+
+void
+init_stats (void)
+{
+  string_count = 0;
+  unique_string_count = 0;
+  string_size = 0;
+  unique_string_size = 0;
+  types_count = 0;
+  unique_types_count = 0;
+}
+
+void
+dump_stats (void)
+{
+  g_message ("%d strings (%d before sharing), %d bytes (%d before sharing)",
+            unique_string_count, string_count, unique_string_size, string_size);
+  g_message ("%d types (%d before sharing)", unique_types_count, types_count);
+}
+
+#define ALIGN_VALUE(this, boundary) \
+  (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
+
+
+GIdlNode *
+g_idl_node_new (GIdlNodeTypeId type)
+{
+  GIdlNode *node = NULL;
+
+  switch (type)
+    {
+   case G_IDL_NODE_FUNCTION:
+      node = g_malloc0 (sizeof (GIdlNodeFunction));
+      break;
+
+   case G_IDL_NODE_PARAM:
+      node = g_malloc0 (sizeof (GIdlNodeParam));
+      break;
+
+   case G_IDL_NODE_TYPE:
+      node = g_malloc0 (sizeof (GIdlNodeType));
+      break;
+
+    case G_IDL_NODE_OBJECT:
+    case G_IDL_NODE_INTERFACE:
+      node = g_malloc0 (sizeof (GIdlNodeInterface));
+      break;
+
+    case G_IDL_NODE_SIGNAL:
+      node = g_malloc0 (sizeof (GIdlNodeSignal));
+      break;
+
+    case G_IDL_NODE_PROPERTY:
+      node = g_malloc0 (sizeof (GIdlNodeProperty));
+      break;
+
+    case G_IDL_NODE_VFUNC:
+      node = g_malloc0 (sizeof (GIdlNodeFunction));
+      break;
+
+    case G_IDL_NODE_FIELD:
+      node = g_malloc0 (sizeof (GIdlNodeField));
+      break;
+
+    case G_IDL_NODE_ENUM:
+    case G_IDL_NODE_FLAGS:
+      node = g_malloc0 (sizeof (GIdlNodeEnum));
+      break;
+
+    case G_IDL_NODE_BOXED:
+      node = g_malloc0 (sizeof (GIdlNodeBoxed));
+      break;
+
+    case G_IDL_NODE_STRUCT:
+      node = g_malloc0 (sizeof (GIdlNodeStruct));
+      break;
+
+    case G_IDL_NODE_VALUE:
+      node = g_malloc0 (sizeof (GIdlNodeValue));
+      break;
+
+    case G_IDL_NODE_CONSTANT:
+      node = g_malloc0 (sizeof (GIdlNodeConstant));
+      break;
+
+    case G_IDL_NODE_ERROR_DOMAIN:
+      node = g_malloc0 (sizeof (GIdlNodeErrorDomain));
+      break;
+
+    case G_IDL_NODE_XREF:
+      node = g_malloc0 (sizeof (GIdlNodeXRef));
+      break;
+
+    case G_IDL_NODE_UNION:
+      node = g_malloc0 (sizeof (GIdlNodeUnion));
+      break;
+
+    default:
+      g_error ("Unhandled node type %d\n", type);
+      break;
+    }
+
+  node->type = type;
+
+  return node;
+}
+
+void
+g_idl_node_free (GIdlNode *node)
+{
+  GList *l;
+
+  if (node == NULL)
+    return;
+
+  switch (node->type)
+    {
+    case G_IDL_NODE_FUNCTION:
+    case G_IDL_NODE_CALLBACK:
+      {
+       GIdlNodeFunction *function = (GIdlNodeFunction *)node;
+       
+       g_free (node->name);
+       g_free (function->symbol);
+       g_idl_node_free ((GIdlNode *)function->result);
+       for (l = function->parameters; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (function->parameters);
+      }
+      break;
+
+    case G_IDL_NODE_TYPE:
+      {
+       GIdlNodeType *type = (GIdlNodeType *)node;
+       
+       g_free (node->name);
+       g_idl_node_free ((GIdlNode *)type->parameter_type1);
+       g_idl_node_free ((GIdlNode *)type->parameter_type2);
+
+       g_free (type->interface);
+       g_strfreev (type->errors);
+
+      }
+      break;
+
+    case G_IDL_NODE_PARAM:
+      {
+       GIdlNodeParam *param = (GIdlNodeParam *)node;
+       
+       g_free (node->name);
+       g_idl_node_free ((GIdlNode *)param->type);
+      }
+      break;
+
+    case G_IDL_NODE_PROPERTY:
+      {
+       GIdlNodeProperty *property = (GIdlNodeProperty *)node;
+       
+       g_free (node->name);
+       g_idl_node_free ((GIdlNode *)property->type);
+      }
+      break;
+
+    case G_IDL_NODE_SIGNAL:
+      {
+       GIdlNodeSignal *signal = (GIdlNodeSignal *)node;
+       
+       g_free (node->name);
+       for (l = signal->parameters; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (signal->parameters);
+       g_idl_node_free ((GIdlNode *)signal->result);
+      }
+      break;
+
+    case G_IDL_NODE_VFUNC:
+      {
+       GIdlNodeVFunc *vfunc = (GIdlNodeVFunc *)node;
+       
+       g_free (node->name);
+       for (l = vfunc->parameters; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (vfunc->parameters);
+       g_idl_node_free ((GIdlNode *)vfunc->result);
+      }
+      break;
+
+    case G_IDL_NODE_FIELD:
+      {
+       GIdlNodeField *field = (GIdlNodeField *)node;
+       
+       g_free (node->name);
+       g_idl_node_free ((GIdlNode *)field->type);
+      }
+      break;
+
+    case G_IDL_NODE_OBJECT:
+    case G_IDL_NODE_INTERFACE:
+      {
+       GIdlNodeInterface *iface = (GIdlNodeInterface *)node;
+       
+       g_free (node->name);
+       g_free (iface->gtype_name);
+       g_free (iface->gtype_init);
+       
+       g_free (iface->parent);
+
+       for (l = iface->interfaces; l; l = l->next)
+         g_free ((GIdlNode *)l->data);
+       g_list_free (iface->interfaces);
+
+       for (l = iface->members; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (iface->members);
+
+      }
+      break;
+ 
+    case G_IDL_NODE_VALUE:
+      {
+       GIdlNodeValue *value = (GIdlNodeValue *)node;
+       
+       g_free (node->name);
+      }
+      break;
+
+    case G_IDL_NODE_ENUM:
+    case G_IDL_NODE_FLAGS:
+      {
+       GIdlNodeEnum *enum_ = (GIdlNodeEnum *)node;
+       
+       g_free (node->name);
+       g_free (enum_->gtype_name);
+       g_free (enum_->gtype_init);
+
+       for (l = enum_->values; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (enum_->values);
+      }
+      break;
+
+    case G_IDL_NODE_BOXED:
+      {
+       GIdlNodeBoxed *boxed = (GIdlNodeBoxed *)node;
+       
+       g_free (node->name);
+       g_free (boxed->gtype_name);
+       g_free (boxed->gtype_init);
+
+       for (l = boxed->members; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (boxed->members);
+      }
+      break;
+
+    case G_IDL_NODE_STRUCT:
+      {
+       GIdlNodeStruct *struct_ = (GIdlNodeStruct *)node;
+
+       g_free (node->name);
+       for (l = struct_->members; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       g_list_free (struct_->members);
+      }
+      break;
+
+    case G_IDL_NODE_CONSTANT:
+      {
+       GIdlNodeConstant *constant = (GIdlNodeConstant *)node;
+       
+       g_free (node->name);
+       g_free (constant->value);
+       g_idl_node_free ((GIdlNode *)constant->type);
+      }
+      break;
+
+    case G_IDL_NODE_ERROR_DOMAIN:
+      {
+       GIdlNodeErrorDomain *domain = (GIdlNodeErrorDomain *)node;
+       
+       g_free (node->name);
+       g_free (domain->getquark);
+       g_free (domain->codes);
+      }
+      break;
+
+    case G_IDL_NODE_XREF:
+      {
+       GIdlNodeXRef *xref = (GIdlNodeXRef *)node;
+       
+       g_free (node->name);
+       g_free (xref->namespace);
+      }
+      break;
+
+    case G_IDL_NODE_UNION:
+      {
+       GIdlNodeUnion *union_ = (GIdlNodeUnion *)node;
+       
+       g_free (node->name);
+       g_free (union_->gtype_name);
+       g_free (union_->gtype_init);
+
+       g_idl_node_free ((GIdlNode *)union_->discriminator_type);
+       for (l = union_->members; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+       for (l = union_->discriminators; l; l = l->next)
+         g_idl_node_free ((GIdlNode *)l->data);
+      }
+      break;
+
+    default:
+      g_error ("Unhandled node type %d\n", node->type);
+      break;
+    } 
+
+  g_free (node);
+}
+
+/* returns the fixed size of the blob */
+guint32
+g_idl_node_get_size (GIdlNode *node)
+{
+  GList *l;
+  gint size, n;
+
+  switch (node->type)
+    {
+    case G_IDL_NODE_CALLBACK:
+      size = 12; 
+      break;
+
+    case G_IDL_NODE_FUNCTION:
+      size = 16; 
+      break;
+
+    case G_IDL_NODE_PARAM:
+      size = 12;
+      break;
+
+    case G_IDL_NODE_TYPE:
+      size = 4;
+      break;
+
+    case G_IDL_NODE_OBJECT:
+      {
+       GIdlNodeInterface *iface = (GIdlNodeInterface *)node;
+
+       n = g_list_length (iface->interfaces);
+       size = 32 + 2 * (n + (n % 2));
+
+       for (l = iface->members; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_INTERFACE:
+      {
+       GIdlNodeInterface *iface = (GIdlNodeInterface *)node;
+
+       n = g_list_length (iface->prerequisites);
+       size = 28 + 2 * (n + (n % 2));
+
+       for (l = iface->members; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_ENUM:
+    case G_IDL_NODE_FLAGS:
+      {
+       GIdlNodeEnum *enum_ = (GIdlNodeEnum *)node;
+       
+       size = 20;
+       for (l = enum_->values; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_VALUE:
+      size = 12;
+      break;
+
+    case G_IDL_NODE_STRUCT:
+      {
+       GIdlNodeStruct *struct_ = (GIdlNodeStruct *)node;
+
+       size = 20;
+       for (l = struct_->members; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_BOXED:
+      {
+       GIdlNodeBoxed *boxed = (GIdlNodeBoxed *)node;
+
+       size = 20;
+       for (l = boxed->members; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_PROPERTY:
+      size = 12;
+      break;
+
+    case G_IDL_NODE_SIGNAL:
+      size = 12;
+      break;
+
+    case G_IDL_NODE_VFUNC:
+      size = 16;
+      break;
+
+    case G_IDL_NODE_FIELD:
+      size = 12;
+      break;
+
+    case G_IDL_NODE_CONSTANT:
+      size = 20;
+      break;
+
+    case G_IDL_NODE_ERROR_DOMAIN:
+      size = 16;
+      break;
+
+    case G_IDL_NODE_XREF:
+      size = 0;
+      break;
+
+    case G_IDL_NODE_UNION:
+      {
+       GIdlNodeUnion *union_ = (GIdlNodeUnion *)node;
+
+       size = 28;
+       for (l = union_->members; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+       for (l = union_->discriminators; l; l = l->next)
+         size += g_idl_node_get_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    default: 
+      g_error ("Unhandled node type %d\n", node->type);
+      size = 0;
+    }
+
+  g_debug ("node %d type %d size %d", node, node->type, size);
+
+  return size;
+}
+
+/* returns the full size of the blob including variable-size parts */
+guint32
+g_idl_node_get_full_size (GIdlNode *node)
+{
+  GList *l;
+  gint size, n;
+
+  g_assert (node != NULL);
+
+  switch (node->type)
+    {
+    case G_IDL_NODE_CALLBACK:
+      {
+       GIdlNodeFunction *function = (GIdlNodeFunction *)node;
+       size = 12; 
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       for (l = function->parameters; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+       size += g_idl_node_get_full_size ((GIdlNode *)function->result);
+      }
+      break;
+
+    case G_IDL_NODE_FUNCTION:
+      {
+       GIdlNodeFunction *function = (GIdlNodeFunction *)node;
+       size = 24;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += ALIGN_VALUE (strlen (function->symbol) + 1, 4);
+       for (l = function->parameters; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+       size += g_idl_node_get_full_size ((GIdlNode *)function->result);
+      }
+      break;
+
+    case G_IDL_NODE_PARAM:
+      {
+       GIdlNodeParam *param = (GIdlNodeParam *)node;
+       
+       size = 12;
+       if (node->name)
+         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += g_idl_node_get_full_size ((GIdlNode *)param->type);     
+      }
+      break;
+
+    case G_IDL_NODE_TYPE:
+      {
+       GIdlNodeType *type = (GIdlNodeType *)node;
+       if (type->tag < TYPE_TAG_ARRAY) 
+         size = 4;
+       else
+         {
+           switch (type->tag)
+             {
+             case TYPE_TAG_ARRAY:
+               size = 4 + 4;
+               if (type->parameter_type1)
+                 size += g_idl_node_get_full_size ((GIdlNode *)type->parameter_type1);
+               break;
+             case TYPE_TAG_INTERFACE:
+               size = 4 + 4;
+               break;
+             case TYPE_TAG_LIST:
+             case TYPE_TAG_SLIST:
+               size = 4 + 4;
+               if (type->parameter_type1)
+                 size += g_idl_node_get_full_size ((GIdlNode *)type->parameter_type1);
+               break;
+             case TYPE_TAG_HASH:
+               size = 4 + 4 + 4;
+               if (type->parameter_type1)
+                 size += g_idl_node_get_full_size ((GIdlNode *)type->parameter_type1);
+               if (type->parameter_type2)
+                 size += g_idl_node_get_full_size ((GIdlNode *)type->parameter_type2);
+               break;
+             case TYPE_TAG_ERROR:
+               {
+                 gint n;
+                 
+                 if (type->errors)
+                   n = g_strv_length (type->errors);
+                 else
+                   n = 0;
+
+                 size = 4 + 4 + 2 * (n + n % 2);
+               }
+               break;
+             default:
+               g_error ("Unknown type tag %d\n", type->tag);
+               break;
+             }
+         }
+      }
+      break;
+
+    case G_IDL_NODE_OBJECT:
+      {
+       GIdlNodeInterface *iface = (GIdlNodeInterface *)node;
+
+       n = g_list_length (iface->interfaces);
+       size = 32;
+       if (iface->parent)
+         size += ALIGN_VALUE (strlen (iface->parent) + 1, 4);
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
+       size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
+       size += 2 * (n + (n % 2));
+
+       for (l = iface->members; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_INTERFACE:
+      {
+       GIdlNodeInterface *iface = (GIdlNodeInterface *)node;
+
+       n = g_list_length (iface->prerequisites);
+       size = 28;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
+       size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
+       size += 2 * (n + (n % 2));
+
+       for (l = iface->members; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_ENUM:
+    case G_IDL_NODE_FLAGS:
+      {
+       GIdlNodeEnum *enum_ = (GIdlNodeEnum *)node;
+       
+       size = 20;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       if (enum_->gtype_name)
+         {
+           size += ALIGN_VALUE (strlen (enum_->gtype_name) + 1, 4);
+           size += ALIGN_VALUE (strlen (enum_->gtype_init) + 1, 4);
+         }
+
+       for (l = enum_->values; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);       
+      }
+      break;
+
+    case G_IDL_NODE_VALUE:
+      {
+       GIdlNodeValue *value = (GIdlNodeValue *)node;
+       
+       size = 12;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+      }
+      break;
+
+    case G_IDL_NODE_STRUCT:
+      {
+       GIdlNodeStruct *struct_ = (GIdlNodeStruct *)node;
+
+       size = 20;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       for (l = struct_->members; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_BOXED:
+      {
+       GIdlNodeBoxed *boxed = (GIdlNodeBoxed *)node;
+
+       size = 20;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       if (boxed->gtype_name)
+         {
+           size += ALIGN_VALUE (strlen (boxed->gtype_name) + 1, 4);
+           size += ALIGN_VALUE (strlen (boxed->gtype_init) + 1, 4);
+         }
+       for (l = boxed->members; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    case G_IDL_NODE_PROPERTY:
+      {
+       GIdlNodeProperty *prop = (GIdlNodeProperty *)node;
+       
+       size = 12;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += g_idl_node_get_full_size ((GIdlNode *)prop->type);      
+      }
+      break;
+
+    case G_IDL_NODE_SIGNAL:
+      {
+       GIdlNodeSignal *signal = (GIdlNodeSignal *)node;
+
+       size = 12;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       for (l = signal->parameters; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+       size += g_idl_node_get_full_size ((GIdlNode *)signal->result);
+      }
+      break;
+
+    case G_IDL_NODE_VFUNC:
+      {
+       GIdlNodeVFunc *vfunc = (GIdlNodeVFunc *)node;
+
+       size = 16;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       for (l = vfunc->parameters; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+       size += g_idl_node_get_full_size ((GIdlNode *)vfunc->result);
+      }
+      break;
+
+    case G_IDL_NODE_FIELD:
+      {
+       GIdlNodeField *field = (GIdlNodeField *)node;
+
+       size = 12;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += g_idl_node_get_full_size ((GIdlNode *)field->type);     
+      }
+      break;
+
+    case G_IDL_NODE_CONSTANT:
+      {
+       GIdlNodeConstant *constant = (GIdlNodeConstant *)node;
+
+       size = 20;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       /* FIXME non-string values */
+       size += ALIGN_VALUE (strlen (constant->value) + 1, 4);
+       size += g_idl_node_get_full_size ((GIdlNode *)constant->type);  
+      }
+      break;
+
+    case G_IDL_NODE_ERROR_DOMAIN:
+      {
+       GIdlNodeErrorDomain *domain = (GIdlNodeErrorDomain *)node;
+
+       size = 16;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += ALIGN_VALUE (strlen (domain->getquark) + 1, 4);
+      }
+      break;
+
+    case G_IDL_NODE_XREF:
+      {
+       GIdlNodeXRef *xref = (GIdlNodeXRef *)node;
+       
+       size = 0;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       size += ALIGN_VALUE (strlen (xref->namespace) + 1, 4);
+      }
+      break;
+
+    case G_IDL_NODE_UNION:
+      {
+       GIdlNodeUnion *union_ = (GIdlNodeUnion *)node;
+
+       size = 28;
+       size += ALIGN_VALUE (strlen (node->name) + 1, 4);
+       for (l = union_->members; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+       for (l = union_->discriminators; l; l = l->next)
+         size += g_idl_node_get_full_size ((GIdlNode *)l->data);
+      }
+      break;
+
+    default: 
+      g_error ("Unknown type tag %d\n", node->type);
+      size = 0;
+    }
+
+  g_debug ("node %d type %d full size %d", node, node->type, size);
+
+  return size;
+}
+
+static gint64
+parse_int_value (const gchar *str)
+{
+  return strtoll (str, NULL, 0);
+}
+
+static guint64
+parse_uint_value (const gchar *str)
+{
+  return strtoull (str, NULL, 0);
+}
+
+static gdouble
+parse_float_value (const gchar *str)
+{
+  return strtod (str, NULL);
+}
+
+static gboolean
+parse_boolean_value (const gchar *str)
+{
+  if (strcmp (str, "TRUE") == 0)
+    return TRUE;
+  
+  if (strcmp (str, "FALSE") == 0)
+    return FALSE;
+
+  return parse_int_value (str) ? TRUE : FALSE;
+}
+
+static GIdlNode *
+find_entry_node (GIdlModule  *module,
+                GList       *modules,
+                const gchar *name,
+                guint16     *idx)
+
+{
+  GList *l;
+  gint i;
+  gchar **names;
+  gint n_names;
+  GIdlNode *result = NULL;
+
+  names = g_strsplit (name, ".", 0);
+  n_names = g_strv_length (names);
+  if (n_names > 2)
+    g_error ("Too many name parts");
+  
+  for (l = module->entries, i = 1; l; l = l->next, i++)
+    {
+      GIdlNode *node = (GIdlNode *)l->data;
+      
+      if (n_names > 1)
+       {
+         if (node->type != G_IDL_NODE_XREF)
+           continue;
+         
+         if (((GIdlNodeXRef *)node)->namespace == NULL ||
+             strcmp (((GIdlNodeXRef *)node)->namespace, names[0]) != 0)
+           continue;
+       }
+        
+      if (strcmp (node->name, names[n_names - 1]) == 0)
+       {
+         if (idx)
+           *idx = i;
+         
+         result = node;
+         goto out;
+       }
+    }
+
+  if (n_names > 1)
+    {
+      GIdlNode *node = g_idl_node_new (G_IDL_NODE_XREF);
+
+      ((GIdlNodeXRef *)node)->namespace = g_strdup (names[0]);
+      node->name = g_strdup (names[1]);
+  
+      module->entries = g_list_append (module->entries, node);
+  
+      if (idx)
+       *idx = g_list_length (module->entries);
+
+      result = node;
+
+      goto out;
+    }
+
+  g_warning ("Entry %s not found", name);
+
+ out:
+
+  g_strfreev (names);
+
+  return result;
+}
+
+static guint16
+find_entry (GIdlModule  *module,
+           GList       *modules,
+           const gchar *name)
+{
+  guint16 idx = 0;
+
+  find_entry_node (module, modules, name, &idx);
+
+  return idx;
+}
+
+static void
+serialize_type (GIdlModule   *module, 
+               GList        *modules,
+               GIdlNodeType *node, 
+               GString      *str)
+{
+  gint i;
+  const gchar* basic[] = {
+    "void", 
+    "gboolean", 
+    "gint8", 
+    "guint8", 
+    "gint16", 
+    "guint16", 
+    "gint32", 
+    "guint32", 
+    "gint64", 
+    "guint64", 
+    "gint",
+    "guint",
+    "glong",
+    "gulong",
+    "gssize",
+    "gsize",
+    "gfloat", 
+    "gdouble", 
+    "utf8", 
+    "filename"
+  };
+  
+  if (node->tag < 20)
+    {
+      g_string_append_printf (str, "%s%s", 
+                             basic[node->tag], node->is_pointer ? "*" : "");
+    }
+  else if (node->tag == 20)
+    {
+      serialize_type (module, modules, node->parameter_type1, str);
+      g_string_append (str, "[");
+
+      if (node->has_length)
+       g_string_append_printf (str, "length=%d", node->length);
+      
+      if (node->zero_terminated)
+       g_string_append_printf (str, "%szero-terminated=1", 
+                               node->has_length ? "," : "");
+      
+      g_string_append (str, "]");
+    }
+  else if (node->tag == 21)
+    {
+      GIdlNode *iface;
+      gchar *name;
+
+      iface = find_entry_node (module, modules, node->interface, NULL);
+      if (iface)
+       name = iface->name;
+      else
+       {
+         g_warning ("Interface for type reference %s not found", node->interface);
+         name = node->interface;
+       }
+
+      g_string_append_printf (str, "%s%s", name, node->is_pointer ? "*" : "");
+    }
+  else if (node->tag == 22)
+    {
+      g_string_append (str, "GList");
+      if (node->parameter_type1)
+       {
+         g_string_append (str, "<"); 
+         serialize_type (module, modules, node->parameter_type1, str);
+         g_string_append (str, ">"); 
+       }
+    }
+  else if (node->tag == 23)
+    {
+      g_string_append (str, "GSList");
+      if (node->parameter_type1)
+       {
+         g_string_append (str, "<"); 
+         serialize_type (module, modules, node->parameter_type1, str);
+         g_string_append (str, ">"); 
+       }
+    }
+  else if (node->tag == 24)
+    {
+      g_string_append (str, "GHashTable<");
+      if (node->parameter_type1)
+       {
+         g_string_append (str, "<"); 
+         serialize_type (module, modules, node->parameter_type1, str);
+         g_string_append (str, ","); 
+         serialize_type (module, modules, node->parameter_type2, str);
+         g_string_append (str, ">"); 
+       }
+    }
+  else if (node->tag == 25) 
+    {
+      g_string_append (str, "GError");
+      if (node->errors)
+       {
+         g_string_append (str, "<"); 
+         for (i = 0; node->errors[i]; i++)
+           {
+             if (i > 0)
+               g_string_append (str, ",");
+             g_string_append (str, node->errors[i]);
+           }
+         g_string_append (str, ">"); 
+       }
+    }
+}
+
+void
+g_idl_node_build_metadata (GIdlNode   *node,
+                          GIdlModule *module,
+                          GList      *modules,
+                          GHashTable *strings,
+                          GHashTable *types,
+                          guchar     *data,
+                          guint32    *offset,
+                           guint32    *offset2)
+{
+  GList *l;
+  guint32 old_offset = *offset;
+  guint32 old_offset2 = *offset2;
+
+  switch (node->type)
+    {
+    case G_IDL_NODE_TYPE:
+      {
+       GIdlNodeType *type = (GIdlNodeType *)node;
+       SimpleTypeBlob *blob = (SimpleTypeBlob *)&data[*offset];
+
+       *offset += 4;
+       
+       if (type->tag < TYPE_TAG_ARRAY)
+         {
+           blob->reserved = 0;
+           blob->reserved2 = 0;
+           blob->pointer = type->is_pointer;
+           blob->reserved3 = 0;
+           blob->tag = type->tag;
+         }
+       else 
+         {
+           GString *str;
+           gchar *s;
+           gpointer value;
+           
+           str = g_string_new (0);
+           serialize_type (module, modules, type, str);
+           s = g_string_free (str, FALSE);
+           
+           types_count += 1;
+           value = g_hash_table_lookup (types, s);
+           if (value)
+             {
+               blob->offset = GPOINTER_TO_INT (value);
+               g_free (s);
+             }
+           else
+             {
+               unique_types_count += 1;
+               g_hash_table_insert (types, s, GINT_TO_POINTER(*offset2));
+                                    
+               blob->offset = *offset2;
+               switch (type->tag)
+                 {
+                 case TYPE_TAG_ARRAY:
+                   {
+                     ArrayTypeBlob *array = (ArrayTypeBlob *)&data[*offset2];
+                     guint32 pos;
+                     
+                     array->pointer = 1;
+                     array->reserved = 0;
+                     array->tag = type->tag;
+                     array->zero_terminated = type->zero_terminated;
+                     array->has_length = type->has_length;
+                     array->reserved2 = 0;
+                     array->length = type->length;
+                     
+                     pos = *offset2 + 4;
+                     *offset2 += 8;
+                     
+                     g_idl_node_build_metadata ((GIdlNode *)type->parameter_type1, 
+                                                module, modules, strings, types, 
+                                                data, &pos, offset2);
+                   }
+                   break;
+                   
+                 case TYPE_TAG_INTERFACE:
+                   {
+                     InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&data[*offset2];
+                     *offset2 += 4;
+
+                     iface->pointer = type->is_pointer;
+                     iface->reserved = 0;
+                     iface->tag = type->tag;
+                     iface->reserved2 = 0;
+                     iface->interface = find_entry (module, modules, type->interface);
+
+                   }
+                   break;
+                   
+                 case TYPE_TAG_LIST:
+                 case TYPE_TAG_SLIST:
+                   {
+                     ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
+                     guint32 pos;
+                     
+                     param->pointer = 1;
+                     param->reserved = 0;
+                     param->tag = type->tag;
+                     param->reserved2 = 0;
+                     param->n_types = 1;
+                     
+                     pos = *offset2 + 4;
+                     *offset2 += 8;
+                     
+                     g_idl_node_build_metadata ((GIdlNode *)type->parameter_type1, 
+                                                module, modules, strings, types,
+                                                data, &pos, offset2);
+                   }
+                   break;
+                   
+                 case TYPE_TAG_HASH:
+                   {
+                     ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
+                     guint32 pos;
+                     
+                     param->pointer = 1;
+                     param->reserved = 0;
+                     param->tag = type->tag;
+                     param->reserved2 = 0;
+                     param->n_types = 2;
+                     
+                     pos = *offset2 + 4;
+                     *offset2 += 12;
+                     
+                     g_idl_node_build_metadata ((GIdlNode *)type->parameter_type1, 
+                                                module, modules, strings, types, 
+                                                data, &pos, offset2);
+                     g_idl_node_build_metadata ((GIdlNode *)type->parameter_type2, 
+                                                module, modules, strings, types, 
+                                                data, &pos, offset2);
+                   }
+                   break;
+                   
+                 case TYPE_TAG_ERROR:
+                   {
+                     ErrorTypeBlob *blob = (ErrorTypeBlob *)&data[*offset2];
+                     gint i, domain;
+                     
+                     blob->pointer = 1;
+                     blob->reserved = 0;
+                     blob->tag = type->tag;
+                     blob->reserved2 = 0;
+                     if (type->errors) 
+                       blob->n_domains = g_strv_length (type->errors);
+                     else
+                       blob->n_domains = 0;
+                     
+                     *offset2 = ALIGN_VALUE (*offset2 + 4 + 2 * blob->n_domains, 4);
+                     for (i = 0; i < blob->n_domains; i++)
+                       blob->domains[i] = find_entry (module, modules, type->errors[i]);
+                   }
+                   break;
+                   
+                 default:
+                   g_error ("Unknown type tag %d\n", type->tag);
+                   break;
+                 }
+             }
+         }
+      }
+      break;
+
+    case G_IDL_NODE_FIELD:
+      {
+       GIdlNodeField *field = (GIdlNodeField *)node;
+       FieldBlob *blob;
+
+       blob = (FieldBlob *)&data[*offset];
+       *offset += 8;
+
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->readable = field->readable;
+       blob->writable = field->writable;
+       blob->reserved = 0;
+       blob->bits = 0;
+       blob->struct_offset = field->offset;
+
+        g_idl_node_build_metadata ((GIdlNode *)field->type, 
+                                  module, modules, strings, types,
+                                  data, offset, offset2);
+      }
+      break;
+
+    case G_IDL_NODE_PROPERTY:
+      {
+       GIdlNodeProperty *prop = (GIdlNodeProperty *)node;
+       PropertyBlob *blob = (PropertyBlob *)&data[*offset];
+       *offset += 8;
+
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->deprecated = prop->deprecated;
+       blob->readable = prop->readable;
+       blob->writable = prop->writable;
+       blob->construct = prop->construct;
+       blob->construct_only = prop->construct_only;
+       blob->reserved = 0;
+
+        g_idl_node_build_metadata ((GIdlNode *)prop->type, 
+                                  module, modules, strings, types,
+                                  data, offset, offset2);
+      }
+      break;
+
+    case G_IDL_NODE_FUNCTION:
+      {
+       FunctionBlob *blob = (FunctionBlob *)&data[*offset];
+       SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
+       GIdlNodeFunction *function = (GIdlNodeFunction *)node;
+       guint32 signature, res;
+       gint n;
+
+       signature = *offset2;
+       n = g_list_length (function->parameters);
+
+       *offset += 16;
+       *offset2 += 8 + n * 12;
+
+       blob->blob_type = BLOB_TYPE_FUNCTION;
+       blob->deprecated = function->deprecated;
+       blob->setter = function->is_setter;
+       blob->getter = function->is_getter;
+       blob->constructor = function->is_constructor;
+       blob->wraps_vfunc = function->wraps_vfunc;
+       blob->reserved = 0;
+       blob->index = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->symbol = write_string (function->symbol, strings, data, offset2);
+       blob->signature = signature;
+       
+        g_idl_node_build_metadata ((GIdlNode *)function->result->type, 
+                                  module, modules, strings, types,
+                                  data, &signature, offset2);
+
+       blob2->may_return_null = function->result->null_ok;
+       blob2->caller_owns_return_value = function->result->transfer;
+       blob2->caller_owns_return_container = function->result->shallow_transfer;
+       blob2->reserved = 0;
+       blob2->n_arguments = n;
+
+       signature += 4;
+       
+       for (l = function->parameters; l; l = l->next)
+         {
+           GIdlNode *param = (GIdlNode *)l->data;
+
+           g_idl_node_build_metadata (param, 
+                                      module, modules, strings, types,
+                                      data, &signature, offset2);
+         }
+      }
+      break;
+
+    case G_IDL_NODE_CALLBACK:
+      {
+       CallbackBlob *blob = (CallbackBlob *)&data[*offset];
+       SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
+       GIdlNodeFunction *function = (GIdlNodeFunction *)node;
+       guint32 signature, res;
+       gint n;
+
+       signature = *offset2;
+       n = g_list_length (function->parameters);
+
+       *offset += 12;
+       *offset2 += 8 + n * 12;
+
+       blob->blob_type = BLOB_TYPE_CALLBACK;
+       blob->deprecated = function->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->signature = signature;
+       
+        g_idl_node_build_metadata ((GIdlNode *)function->result->type, 
+                                  module, modules, strings, types,
+                                  data, &signature, offset2);
+
+       blob2->may_return_null = function->result->null_ok;
+       blob2->caller_owns_return_value = function->result->transfer;
+       blob2->caller_owns_return_container = function->result->shallow_transfer;
+       blob2->reserved = 0;
+       blob2->n_arguments = n;
+
+       signature += 4;
+       
+       for (l = function->parameters; l; l = l->next)
+         {
+           GIdlNode *param = (GIdlNode *)l->data;
+
+           g_idl_node_build_metadata (param, 
+                                      module, modules, strings, types,
+                                      data, &signature, offset2);
+         }
+      }
+      break;
+
+    case G_IDL_NODE_SIGNAL:
+      {
+       SignalBlob *blob = (SignalBlob *)&data[*offset];
+       SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
+       GIdlNodeSignal *signal = (GIdlNodeSignal *)node;
+       guint32 signature, res;
+       gint n;
+
+       signature = *offset2;
+       n = g_list_length (signal->parameters);
+
+       *offset += 12;
+       *offset2 += 8 + n * 12;
+
+       blob->deprecated = signal->deprecated;
+       blob->run_first = signal->run_first;
+       blob->run_last = signal->run_last;
+       blob->run_cleanup = signal->run_cleanup;
+       blob->no_recurse = signal->no_recurse;
+       blob->detailed = signal->detailed;
+       blob->action = signal->action;
+       blob->no_hooks = signal->no_hooks;
+       blob->has_class_closure = 0; /* FIXME */
+       blob->true_stops_emit = 0; /* FIXME */
+       blob->reserved = 0;
+       blob->class_closure = 0; /* FIXME */
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->signature = signature;
+       
+        g_idl_node_build_metadata ((GIdlNode *)signal->result->type, 
+                                  module, modules, strings, types,
+                                  data, &signature, offset2);
+
+       blob2->may_return_null = signal->result->null_ok;
+       blob2->caller_owns_return_value = signal->result->transfer;
+       blob2->caller_owns_return_container = signal->result->shallow_transfer;
+       blob2->reserved = 0;
+       blob2->n_arguments = n;
+
+       signature += 4;
+       
+       for (l = signal->parameters; l; l = l->next)
+         {
+           GIdlNode *param = (GIdlNode *)l->data;
+
+           g_idl_node_build_metadata (param, module, modules, strings, types,
+                                      data, &signature, offset2);
+         }
+      }
+      break;
+
+    case G_IDL_NODE_VFUNC:
+      {
+       VFuncBlob *blob = (VFuncBlob *)&data[*offset];
+       SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
+       GIdlNodeVFunc *vfunc = (GIdlNodeVFunc *)node;
+       guint32 signature, res;
+       gint n;
+
+       signature = *offset2;
+       n = g_list_length (vfunc->parameters);
+
+       *offset += 16;
+       *offset2 += 8 + n * 12;
+
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->must_chain_up = 0; /* FIXME */
+       blob->must_be_implemented = 0; /* FIXME */
+       blob->must_not_be_implemented = 0; /* FIXME */
+       blob->class_closure = 0; /* FIXME */
+       blob->reserved = 0;
+
+       blob->struct_offset = vfunc->offset;
+       blob->reserved2 = 0;
+       blob->signature = signature;
+       
+        g_idl_node_build_metadata ((GIdlNode *)vfunc->result->type, 
+                                  module, modules, strings, types,
+                                  data, &signature, offset2);
+
+       blob2->may_return_null = vfunc->result->null_ok;
+       blob2->caller_owns_return_value = vfunc->result->transfer;
+       blob2->caller_owns_return_container = vfunc->result->shallow_transfer;
+       blob2->reserved = 0;
+       blob2->n_arguments = n;
+
+       signature += 4;
+       
+       for (l = vfunc->parameters; l; l = l->next)
+         {
+           GIdlNode *param = (GIdlNode *)l->data;
+
+           g_idl_node_build_metadata (param, module, modules, strings, 
+                                      types, data, &signature, offset2);
+         }
+      }
+      break;
+
+    case G_IDL_NODE_PARAM:
+      {
+       ArgBlob *blob = (ArgBlob *)&data[*offset];
+       GIdlNodeParam *param = (GIdlNodeParam *)node;
+       guint32 res;
+
+       *offset += 8;
+
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->in = param->in;
+       blob->out = param->out;
+       blob->dipper = param->dipper;
+       blob->null_ok = param->null_ok;
+       blob->optional = param->optional;
+       blob->transfer_ownership = param->transfer;
+       blob->transfer_container_ownership = param->shallow_transfer;
+       blob->return_value = param->retval;
+       blob->reserved = 0;
+
+        g_idl_node_build_metadata ((GIdlNode *)param->type, module, modules, 
+                                  strings, types, data, offset, offset2);
+      }
+      break;
+
+    case G_IDL_NODE_STRUCT:
+      {
+       StructBlob *blob = (StructBlob *)&data[*offset];
+       GIdlNodeStruct *struct_ = (GIdlNodeStruct *)node;
+       guint32 pos;
+       
+       blob->blob_type = BLOB_TYPE_STRUCT;
+       blob->deprecated = struct_->deprecated;
+       blob->unregistered = TRUE;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->gtype_name = 0;
+       blob->gtype_init = 0;
+
+       blob->n_fields = 0;
+       blob->n_methods = 0;
+
+       *offset += 20; 
+       for (l = struct_->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FIELD)
+             {
+               blob->n_fields++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       for (l = struct_->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+           
+           if (member->type == G_IDL_NODE_FUNCTION)
+             {
+               blob->n_methods++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+      }
+      break;
+
+    case G_IDL_NODE_BOXED:
+      {
+       StructBlob *blob = (StructBlob *)&data[*offset];
+       GIdlNodeBoxed *boxed = (GIdlNodeBoxed *)node;
+
+       blob->blob_type = BLOB_TYPE_BOXED;
+       blob->deprecated = boxed->deprecated;
+       blob->unregistered = FALSE;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->gtype_name = write_string (boxed->gtype_name, strings, data, offset2);
+       blob->gtype_init = write_string (boxed->gtype_init, strings, data, offset2);
+
+       blob->n_fields = 0;
+       blob->n_methods = 0;
+
+       *offset += 20; 
+       for (l = boxed->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FIELD)
+             {
+               blob->n_fields++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       for (l = boxed->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FUNCTION)
+             {
+               blob->n_methods++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+      }
+      break;
+
+    case G_IDL_NODE_UNION:
+      {
+       UnionBlob *blob = (UnionBlob *)&data[*offset];
+       GIdlNodeUnion *union_ = (GIdlNodeUnion *)node;
+
+       blob->blob_type = BLOB_TYPE_UNION;
+       blob->deprecated = union_->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       if (union_->gtype_name)
+         {
+           blob->unregistered = FALSE;
+           blob->gtype_name = write_string (union_->gtype_name, strings, data, offset2);
+           blob->gtype_init = write_string (union_->gtype_init, strings, data, offset2);
+         }
+       else
+         {
+           blob->unregistered = TRUE;
+           blob->gtype_name = 0;
+           blob->gtype_init = 0;
+         }
+
+       blob->n_fields = 0;
+       blob->n_functions = 0;
+
+       blob->discriminator_offset = union_->discriminator_offset;
+
+       if (union_->discriminator_type)
+         {
+           *offset += 24;
+           blob->discriminated = TRUE;
+           g_idl_node_build_metadata ((GIdlNode *)union_->discriminator_type, 
+                                      module, modules, strings, types,
+                                      data, offset, offset2);
+         }
+       else 
+         {
+           *offset += 28;
+           blob->discriminated = FALSE;
+           blob->discriminator_type.offset = 0;
+         }
+       
+       
+       for (l = union_->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FIELD)
+             {
+               blob->n_fields++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       for (l = union_->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FUNCTION)
+             {
+               blob->n_functions++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       if (union_->discriminator_type)
+         {
+           for (l = union_->discriminators; l; l = l->next)
+             {
+               GIdlNode *member = (GIdlNode *)l->data;
+               
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+      }
+      break;
+
+    case G_IDL_NODE_ENUM:
+    case G_IDL_NODE_FLAGS:
+      {
+       EnumBlob *blob = (EnumBlob *)&data[*offset];
+       GIdlNodeEnum *enum_ = (GIdlNodeEnum *)node;
+
+       *offset += 20; 
+       
+       if (node->type == G_IDL_NODE_ENUM)
+         blob->blob_type = BLOB_TYPE_ENUM;
+       else
+         blob->blob_type = BLOB_TYPE_FLAGS;
+         
+       blob->deprecated = enum_->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       if (enum_->gtype_name)
+         {
+           blob->unregistered = FALSE;
+           blob->gtype_name = write_string (enum_->gtype_name, strings, data, offset2);
+           blob->gtype_init = write_string (enum_->gtype_init, strings, data, offset2);
+         }
+       else
+         {
+           blob->unregistered = TRUE;
+           blob->gtype_name = 0;
+           blob->gtype_init = 0;
+         }
+
+       blob->n_values = 0;
+       blob->reserved2 = 0;
+
+       for (l = enum_->values; l; l = l->next)
+         {
+           GIdlNode *value = (GIdlNode *)l->data;
+
+           blob->n_values++;
+           g_idl_node_build_metadata (value, module, modules, strings, types,
+                                      data, offset, offset2);
+         }
+      }
+      break;
+      
+    case G_IDL_NODE_OBJECT:
+      {
+       ObjectBlob *blob = (ObjectBlob *)&data[*offset];
+       GIdlNodeInterface *object = (GIdlNodeInterface *)node;
+       gint parent;
+
+       blob->blob_type = BLOB_TYPE_OBJECT;
+       blob->deprecated = object->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->gtype_name = write_string (object->gtype_name, strings, data, offset2);
+       blob->gtype_init = write_string (object->gtype_init, strings, data, offset2);
+       if (object->parent)
+         blob->parent = find_entry (module, modules, object->parent);
+       else
+         blob->parent = 0;
+
+       blob->n_interfaces = 0;
+       blob->n_fields = 0;
+       blob->n_properties = 0;
+       blob->n_methods = 0;
+       blob->n_signals = 0;
+       blob->n_vfuncs = 0;
+       blob->n_constants = 0;
+       
+       *offset += 32;
+       for (l = object->interfaces; l; l = l->next)
+         {
+           blob->n_interfaces++;
+           *(guint16*)&data[*offset] = find_entry (module, modules, (gchar *)l->data);
+           *offset += 2;
+         }
+       
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = object->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FIELD)
+             {
+               blob->n_fields++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = object->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_PROPERTY)
+             {
+               blob->n_properties++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = object->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FUNCTION)
+             {
+               blob->n_methods++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = object->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_SIGNAL)
+             {
+               blob->n_signals++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = object->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_VFUNC)
+             {
+               blob->n_vfuncs++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = object->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_CONSTANT)
+             {
+               blob->n_constants++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+      }
+      break;
+
+    case G_IDL_NODE_INTERFACE:
+      {
+       InterfaceBlob *blob = (InterfaceBlob *)&data[*offset];
+       GIdlNodeInterface *iface = (GIdlNodeInterface *)node;
+
+       blob->blob_type = BLOB_TYPE_INTERFACE;
+       blob->deprecated = iface->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->gtype_name = write_string (iface->gtype_name, strings, data, offset2);
+       blob->gtype_init = write_string (iface->gtype_init, strings, data, offset2);
+       blob->n_prerequisites = 0;
+       blob->n_properties = 0;
+       blob->n_methods = 0;
+       blob->n_signals = 0;
+       blob->n_vfuncs = 0;
+       blob->n_constants = 0;
+       
+       *offset += 28;
+       for (l = iface->prerequisites; l; l = l->next)
+         {
+           blob->n_prerequisites++;
+           *(guint16*)&data[*offset] = find_entry (module, modules, (gchar *)l->data);
+           *offset += 2;
+         }
+       
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = iface->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_PROPERTY)
+             {
+               blob->n_properties++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = iface->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_FUNCTION)
+             {
+               blob->n_methods++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = iface->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_SIGNAL)
+             {
+               blob->n_signals++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = iface->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_VFUNC)
+             {
+               blob->n_vfuncs++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+
+       *offset = ALIGN_VALUE (*offset, 4);
+       for (l = iface->members; l; l = l->next)
+         {
+           GIdlNode *member = (GIdlNode *)l->data;
+
+           if (member->type == G_IDL_NODE_CONSTANT)
+             {
+               blob->n_constants++;
+               g_idl_node_build_metadata (member, module, modules, strings, 
+                                          types, data, offset, offset2);
+             }
+         }
+      }
+      break;
+
+
+    case G_IDL_NODE_VALUE:
+      {
+       GIdlNodeValue *value = (GIdlNodeValue *)node;
+       ValueBlob *blob = (ValueBlob *)&data[*offset];
+       *offset += 12;
+
+       blob->deprecated = value->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->value = value->value;
+      }
+      break;
+
+    case G_IDL_NODE_ERROR_DOMAIN:
+      {
+       GIdlNodeErrorDomain *domain = (GIdlNodeErrorDomain *)node;
+       ErrorDomainBlob *blob = (ErrorDomainBlob *)&data[*offset];
+       *offset += 16;
+
+       blob->blob_type = BLOB_TYPE_ERROR_DOMAIN;
+       blob->deprecated = domain->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+       blob->get_quark = write_string (domain->getquark, strings, data, offset2);
+       blob->error_codes = find_entry (module, modules, domain->codes);
+       blob->reserved2 = 0;
+      }
+      break;
+
+    case G_IDL_NODE_CONSTANT:
+      {
+       GIdlNodeConstant *constant = (GIdlNodeConstant *)node;
+       ConstantBlob *blob = (ConstantBlob *)&data[*offset];
+       guint32 pos;
+
+       pos = *offset + 8;
+       *offset += 20;
+
+       blob->blob_type = BLOB_TYPE_CONSTANT;
+       blob->deprecated = constant->deprecated;
+       blob->reserved = 0;
+       blob->name = write_string (node->name, strings, data, offset2);
+
+       blob->offset = *offset2;
+       switch (constant->type->tag)
+         {
+         case TYPE_TAG_BOOLEAN:
+           blob->size = 4;
+           *(gboolean*)&data[blob->offset] = parse_boolean_value (constant->value);
+           break;
+           case TYPE_TAG_INT8:
+           blob->size = 1;
+             *(gint8*)&data[blob->offset] = (gint8) parse_int_value (constant->value);
+           break;
+         case TYPE_TAG_UINT8:
+           blob->size = 1;
+           *(guint8*)&data[blob->offset] = (guint8) parse_uint_value (constant->value);
+           break;
+         case TYPE_TAG_INT16:
+           blob->size = 2;
+           *(gint16*)&data[blob->offset] = (gint16) parse_int_value (constant->value);
+           break;
+         case TYPE_TAG_UINT16:
+           blob->size = 2;
+           *(guint16*)&data[blob->offset] = (guint16) parse_uint_value (constant->value);
+           break;
+         case TYPE_TAG_INT32:
+           blob->size = 4;
+           *(gint32*)&data[blob->offset] = (gint32) parse_int_value (constant->value);
+           break;
+         case TYPE_TAG_UINT32:
+           blob->size = 4;
+           *(guint32*)&data[blob->offset] = (guint32) parse_uint_value (constant->value);
+           break;
+         case TYPE_TAG_INT64:
+           blob->size = 8;
+           *(gint64*)&data[blob->offset] = (gint64) parse_int_value (constant->value);
+           break;
+         case TYPE_TAG_UINT64:
+           blob->size = 8;
+           *(guint64*)&data[blob->offset] = (guint64) parse_uint_value (constant->value);
+           break;
+         case TYPE_TAG_INT:
+           blob->size = sizeof (gint);
+           *(gint*)&data[blob->offset] = (gint) parse_int_value (constant->value);
+           break;
+         case TYPE_TAG_UINT:
+           blob->size = sizeof (guint);
+           *(gint*)&data[blob->offset] = (guint) parse_uint_value (constant->value);
+           break;
+         case TYPE_TAG_SSIZE: /* FIXME */
+         case TYPE_TAG_LONG:
+           blob->size = sizeof (glong);
+           *(glong*)&data[blob->offset] = (glong) parse_int_value (constant->value);
+           break;
+         case TYPE_TAG_SIZE: /* FIXME */
+         case TYPE_TAG_ULONG:
+           blob->size = sizeof (gulong);
+           *(gulong*)&data[blob->offset] = (gulong) parse_uint_value (constant->value);
+           break;
+         case TYPE_TAG_FLOAT:
+           blob->size = sizeof (gfloat);
+           *(gfloat*)&data[blob->offset] = (gfloat) parse_float_value (constant->value);
+           break;
+         case TYPE_TAG_DOUBLE:
+           blob->size = sizeof (gdouble);
+           *(gdouble*)&data[blob->offset] = (gdouble) parse_float_value (constant->value);
+           break;
+         case TYPE_TAG_UTF8:
+         case TYPE_TAG_FILENAME:
+           blob->size = strlen (constant->value) + 1;
+           memcpy (&data[blob->offset], constant->value, blob->size);
+           break;
+         }
+       *offset2 += ALIGN_VALUE (blob->size, 4);
+       
+       g_idl_node_build_metadata ((GIdlNode *)constant->type, module, modules, 
+                                  strings, types, data, &pos, offset2);
+      }
+      break;
+    }
+  
+  g_debug ("node %p type %d, offset %d -> %d, offset2 %d -> %d",
+          node, node->type, old_offset, *offset, old_offset2, *offset2);
+
+  if (*offset2 - old_offset2 + *offset - old_offset > g_idl_node_get_full_size (node))
+    g_error ("exceeding space reservation !!");
+}
+
+/* if str is already in the pool, return previous location, otherwise write str
+ * to the metadata at offset, put it in the pool and update offset. If the 
+ * metadata is not large enough to hold the string, reallocate it.
+ */
+guint32 
+write_string (const gchar *str,
+             GHashTable  *strings, 
+             guchar      *data,
+             guint32     *offset)
+{
+  gpointer value;
+  guint32 start;
+
+  string_count += 1;
+  string_size += strlen (str);
+
+  value = g_hash_table_lookup (strings, str);
+  
+  if (value)
+    return GPOINTER_TO_INT (value);
+
+  unique_string_count += 1;
+  unique_string_size += strlen (str);
+
+  g_hash_table_insert (strings, (gpointer)str, GINT_TO_POINTER (*offset));
+
+  start = *offset;
+  *offset = ALIGN_VALUE (start + strlen (str) + 1, 4);
+
+  strcpy ((gchar*)&data[start], str);
+  
+  return start;
+}
+

diff --git a/vapigen/gobject-introspection/gidlnode.h b/vapigen/gobject-introspection/gidlnode.h
new file mode 100644 (file)
index 0000000..7b6f156
--- /dev/null
+++ b/vapigen/gobject-introspection/gidlnode.h
@@ -0,0 +1,331 @@
+/* GObject introspection: Parsed IDL
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_IDL_NODE_H__
+#define __G_IDL_NODE_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+typedef struct _GIdlNode GIdlNode; 
+typedef struct _GIdlNodeFunction GIdlNodeFunction;
+typedef struct _GIdlNodeParam GIdlNodeParam;
+typedef struct _GIdlNodeType GIdlNodeType;
+typedef struct _GIdlNodeInterface GIdlNodeInterface;
+typedef struct _GIdlNodeSignal GIdlNodeSignal;
+typedef struct _GIdlNodeProperty GIdlNodeProperty;
+typedef struct _GIdlNodeVFunc GIdlNodeVFunc;
+typedef struct _GIdlNodeField GIdlNodeField;
+typedef struct _GIdlNodeValue GIdlNodeValue;
+typedef struct _GIdlNodeEnum GIdlNodeEnum;
+typedef struct _GIdlNodeBoxed GIdlNodeBoxed;
+typedef struct _GIdlNodeStruct GIdlNodeStruct;
+typedef struct _GIdlNodeConstant GIdlNodeConstant;
+typedef struct _GIdlNodeErrorDomain GIdlNodeErrorDomain;
+typedef struct _GIdlNodeXRef GIdlNodeXRef;
+typedef struct _GIdlNodeUnion GIdlNodeUnion;
+
+typedef enum 
+{
+  G_IDL_NODE_INVALID,
+  G_IDL_NODE_FUNCTION,
+  G_IDL_NODE_CALLBACK,
+  G_IDL_NODE_STRUCT,
+  G_IDL_NODE_BOXED,
+  G_IDL_NODE_ENUM,
+  G_IDL_NODE_FLAGS,
+  G_IDL_NODE_OBJECT,
+  G_IDL_NODE_INTERFACE,
+  G_IDL_NODE_CONSTANT,
+  G_IDL_NODE_ERROR_DOMAIN,
+  G_IDL_NODE_UNION,
+  G_IDL_NODE_PARAM,
+  G_IDL_NODE_TYPE,
+  G_IDL_NODE_PROPERTY,
+  G_IDL_NODE_SIGNAL,
+  G_IDL_NODE_VALUE,
+  G_IDL_NODE_VFUNC,
+  G_IDL_NODE_FIELD,
+  G_IDL_NODE_XREF
+} GIdlNodeTypeId;
+
+struct _GIdlNode
+{
+  GIdlNodeTypeId type;
+  gchar *name;
+};
+
+struct _GIdlNodeXRef
+{
+  GIdlNode node;
+
+  gchar *namespace;
+};
+
+struct _GIdlNodeFunction
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  gboolean is_method;
+  gboolean is_setter;
+  gboolean is_getter;
+  gboolean is_constructor;
+  gboolean wraps_vfunc;
+
+  gchar *symbol;
+
+  GIdlNodeParam *result;
+  GList *parameters;
+};
+
+struct _GIdlNodeType 
+{
+  GIdlNode node;
+
+  gboolean is_pointer;
+  gboolean is_basic;
+  gboolean is_array;
+  gboolean is_glist;
+  gboolean is_gslist;
+  gboolean is_ghashtable;
+  gboolean is_interface;
+  gboolean is_error;
+  gint tag;
+
+  gchar *unparsed;
+
+  gboolean zero_terminated;
+  gboolean has_length;
+  gint length;
+  
+  GIdlNodeType *parameter_type1;
+  GIdlNodeType *parameter_type2;  
+
+  gchar *interface;
+  gchar **errors;
+};
+
+struct _GIdlNodeParam 
+{
+  GIdlNode node;
+
+  gboolean in;
+  gboolean out;
+  gboolean dipper;
+  gboolean optional;
+  gboolean retval;
+  gboolean null_ok;
+  gboolean transfer;
+  gboolean shallow_transfer;
+  
+  GIdlNodeType *type;
+};
+
+struct _GIdlNodeProperty
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  gchar *name;
+  gboolean readable;
+  gboolean writable;
+  gboolean construct;
+  gboolean construct_only;
+  
+  GIdlNodeType *type;
+};
+
+struct _GIdlNodeSignal 
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  gboolean run_first;
+  gboolean run_last;
+  gboolean run_cleanup;
+  gboolean no_recurse;
+  gboolean detailed;
+  gboolean action;
+  gboolean no_hooks;
+  
+  gboolean has_class_closure;
+  gboolean true_stops_emit;
+  
+  gint class_closure;
+  
+  GList *parameters;
+  GIdlNodeParam *result;    
+};
+
+struct _GIdlNodeVFunc 
+{
+  GIdlNode node;
+
+  gboolean must_chain_up;
+  gboolean must_be_implemented;
+  gboolean must_not_be_implemented;
+  gboolean is_class_closure;
+  
+  GList *parameters;
+  GIdlNodeParam *result;      
+
+  gint offset;
+};
+
+struct _GIdlNodeField
+{
+  GIdlNode node;
+
+  gboolean readable;
+  gboolean writable;
+  gint bits;
+  gint offset;
+  
+  GIdlNodeType *type;
+};
+
+struct _GIdlNodeInterface
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  gchar *gtype_name;
+  gchar *gtype_init;
+
+  gchar *parent;
+  
+  GList *interfaces;
+  GList *prerequisites;
+
+  GList *members;
+};
+
+struct _GIdlNodeValue
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  guint32 value;
+};
+
+struct _GIdlNodeConstant
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  GIdlNodeType *type;
+  
+  gchar *value;
+};
+
+struct _GIdlNodeEnum
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  gchar *gtype_name;
+  gchar *gtype_init;
+
+  GList *values;
+};
+
+struct _GIdlNodeBoxed
+{ 
+  GIdlNode node;
+
+  gboolean deprecated;
+
+  gchar *gtype_name;
+  gchar *gtype_init;
+  
+  GList *members;
+};
+
+struct _GIdlNodeStruct
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+  
+  GList *members;
+};
+
+struct _GIdlNodeUnion
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+  
+  GList *members;
+  GList *discriminators;
+
+  gchar *gtype_name;
+  gchar *gtype_init;
+
+  gint discriminator_offset;
+  GIdlNodeType *discriminator_type;
+};
+
+
+struct _GIdlNodeErrorDomain
+{
+  GIdlNode node;
+
+  gboolean deprecated;
+  
+  gchar *name;
+  gchar *getquark;
+  gchar *codes;
+};
+
+
+GIdlNode *g_idl_node_new             (GIdlNodeTypeId type);
+void      g_idl_node_free            (GIdlNode    *node);
+guint32   g_idl_node_get_size        (GIdlNode    *node);
+guint32   g_idl_node_get_full_size   (GIdlNode    *node);
+void      g_idl_node_build_metadata  (GIdlNode    *node,
+                                     GIdlModule  *module,
+                                     GList       *modules,
+                                      GHashTable  *strings,
+                                      GHashTable  *types,
+                                     guchar      *data,
+                                     guint32     *offset,
+                                      guint32     *offset2);
+
+guint32   write_string               (const gchar *str,
+                                     GHashTable  *strings, 
+                                     guchar      *data,
+                                     guint32     *offset);
+
+void      init_stats                 (void);
+void      dump_stats                 (void);
+
+G_END_DECLS
+
+#endif  /* __G_IDL_NODE_H__ */

diff --git a/vapigen/gobject-introspection/gidlparser.c b/vapigen/gobject-introspection/gidlparser.c
new file mode 100644 (file)
index 0000000..b774bb9
--- /dev/null
+++ b/vapigen/gobject-introspection/gidlparser.c
@@ -0,0 +1,2036 @@
+/* GObject introspection: A parser for the XML IDL format
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include <string.h>
+
+#include <glib.h>
+#include "gidlmodule.h"
+#include "gidlnode.h"
+#include "gmetadata.h"
+
+typedef enum
+{
+  STATE_START,
+  STATE_END,
+  STATE_ROOT,
+  STATE_NAMESPACE,
+  STATE_FUNCTION,
+  STATE_PARAMETERS,
+  STATE_OBJECT,
+  STATE_INTERFACE,
+  STATE_IMPLEMENTS,
+  STATE_REQUIRES,
+  STATE_ENUM,
+  STATE_BOXED,
+  STATE_STRUCT,
+  STATE_SIGNAL,
+  STATE_ERRORDOMAIN,
+  STATE_UNION
+} ParseState;
+
+typedef struct _ParseContext ParseContext;
+struct _ParseContext
+{
+  ParseState state;
+  ParseState prev_state;
+
+  GList *modules;
+
+  GIdlModule *current_module;
+  GIdlNode *current_node;
+};
+
+#define MISSING_ATTRIBUTE(error,element,attribute)                            \
+  g_set_error (error,                                                         \
+              G_MARKUP_ERROR,                                                \
+              G_MARKUP_ERROR_INVALID_CONTENT,                                \
+              "The attribute '%s' on the element '%s' must be specified",    \
+              attribute, element)
+
+static const gchar *
+find_attribute (const gchar  *name, 
+               const gchar **attribute_names,
+               const gchar **attribute_values)
+{
+  gint i;
+  
+  for (i = 0; attribute_names[i] != NULL; i++)
+    if (strcmp (attribute_names[i], name) == 0)
+      return attribute_values[i];
+  
+  return 0;
+}
+
+static GIdlNodeType *
+parse_type_internal (gchar *str, gchar **rest)
+{
+  gint i;
+
+  static struct {
+    const gchar *str;
+    gint tag;
+    gboolean pointer;
+  } basic[] = {
+    { "void",     TYPE_TAG_VOID,    0 },
+    { "gpointer", TYPE_TAG_VOID,    1 },
+    { "gboolean", TYPE_TAG_BOOLEAN, 0 },
+    { "int8_t",   TYPE_TAG_INT8,    0 },
+    { "int8",     TYPE_TAG_INT8,    0 },
+    { "gint8",    TYPE_TAG_INT8,    0 },
+    { "uint8_t",  TYPE_TAG_UINT8,   0 },
+    { "uint8",    TYPE_TAG_UINT8,   0 },
+    { "guint8",   TYPE_TAG_UINT8,   0 },
+    { "int16_t",  TYPE_TAG_INT16,   0 },
+    { "int16",    TYPE_TAG_INT16,   0 },
+    { "gint16",   TYPE_TAG_INT16,   0 },
+    { "uint16_t", TYPE_TAG_UINT16,  0 },
+    { "uint16",   TYPE_TAG_UINT16,  0 },
+    { "guint16",  TYPE_TAG_UINT16,  0 },
+    { "int32_t",  TYPE_TAG_INT32,   0 },
+    { "int32",    TYPE_TAG_INT32,   0 },
+    { "gint32",   TYPE_TAG_INT32,   0 },
+    { "uint32_t", TYPE_TAG_UINT32,  0 },
+    { "uint32",   TYPE_TAG_UINT32,  0 },
+    { "guint32",  TYPE_TAG_UINT32,  0 },
+    { "int64_t",  TYPE_TAG_INT64,   0 },
+    { "int64",    TYPE_TAG_INT64,   0 },
+    { "gint64",   TYPE_TAG_INT64,   0 },
+    { "uint64_t", TYPE_TAG_UINT64,  0 },
+    { "uint64",   TYPE_TAG_UINT64,  0 },
+    { "guint64",  TYPE_TAG_UINT64,  0 },
+    { "int",      TYPE_TAG_INT,     0 },
+    { "gint",     TYPE_TAG_INT,     0 },
+    { "uint",     TYPE_TAG_UINT,    0 },
+    { "guint",    TYPE_TAG_UINT,    0 },
+    { "long",     TYPE_TAG_LONG,    0 },
+    { "glong",    TYPE_TAG_LONG,    0 },
+    { "ulong",    TYPE_TAG_ULONG,   0 },
+    { "gulong",   TYPE_TAG_ULONG,   0 },
+    { "ssize_t",  TYPE_TAG_SSIZE,   0 },
+    { "gssize",   TYPE_TAG_SSIZE,   0 },
+    { "size_t",   TYPE_TAG_SIZE,    0 },
+    { "gsize",    TYPE_TAG_SIZE,    0 },
+    { "float",    TYPE_TAG_FLOAT,   0 },
+    { "gfloat",   TYPE_TAG_FLOAT,   0 },
+    { "double",   TYPE_TAG_DOUBLE,  0 },
+    { "gdouble",  TYPE_TAG_DOUBLE,  0 },
+    { "utf8",     TYPE_TAG_UTF8,    1 },  
+    { "gchar*",   TYPE_TAG_UTF8,    1 },  
+    { "filename", TYPE_TAG_FILENAME,1 }
+  };  
+
+  gint n_basic = G_N_ELEMENTS (basic);
+  gchar *start, *end;
+  
+  GIdlNodeType *type;
+  
+  type = (GIdlNodeType *)g_idl_node_new (G_IDL_NODE_TYPE);
+  
+  str = g_strstrip (str);
+
+  type->unparsed = g_strdup (str);
+ 
+  *rest = str;
+  for (i = 0; i < n_basic; i++)
+    {
+      if (g_str_has_prefix (*rest, basic[i].str))
+       {
+         type->is_basic = TRUE;
+         type->tag = basic[i].tag;
+         type->is_pointer = basic[i].pointer;
+
+         *rest += strlen(basic[i].str);
+         *rest = g_strchug (*rest);
+         if (**rest == '*' && !type->is_pointer)
+           {
+             type->is_pointer = TRUE;
+             (*rest)++;
+           }
+
+         break;
+       }
+    }
+
+  if (i < n_basic)
+    /* found a basic type */;
+  else if (g_str_has_prefix (*rest, "GList") ||
+          g_str_has_prefix (*rest, "GSList"))
+    {
+      if (g_str_has_prefix (*rest, "GList"))
+       {
+         type->tag = TYPE_TAG_LIST;
+         type->is_glist = TRUE;
+         type->is_pointer = TRUE;
+         *rest += strlen ("GList");
+       }
+      else
+       {
+         type->tag = TYPE_TAG_SLIST;
+         type->is_gslist = TRUE;
+         type->is_pointer = TRUE;
+         *rest += strlen ("GSList");
+       }
+      
+      *rest = g_strchug (*rest);
+      
+      if (**rest == '<')
+       {
+         (*rest)++;
+         
+         type->parameter_type1 = parse_type_internal (*rest, rest);
+         if (type->parameter_type1 == NULL)
+           goto error;
+         
+         *rest = g_strchug (*rest);
+         
+         if ((*rest)[0] != '>')
+           goto error;
+         (*rest)++;
+       }
+    }
+  else if (g_str_has_prefix (*rest, "GHashTable"))
+    {
+      type->tag = TYPE_TAG_HASH;
+      type->is_ghashtable = TRUE;
+      type->is_pointer = TRUE;
+      *rest += strlen ("GHashTable");
+      
+      *rest = g_strchug (*rest);
+      
+      if (**rest == '<')
+       {
+         (*rest)++;
+      
+         type->parameter_type1 = parse_type_internal (*rest, rest);
+         if (type->parameter_type1 == NULL)
+           goto error;
+      
+         *rest = g_strchug (*rest);
+         
+         if ((*rest)[0] != ',')
+           goto error;
+         (*rest)++;
+         
+         type->parameter_type2 = parse_type_internal (*rest, rest);
+         if (type->parameter_type2 == NULL)
+           goto error;
+      
+         if ((*rest)[0] != '>')
+           goto error;
+         (*rest)++;
+       }
+    }
+  else if (g_str_has_prefix (*rest, "GError"))
+    {
+      type->tag = TYPE_TAG_ERROR;
+      type->is_error = TRUE;
+      type->is_pointer = TRUE;
+      *rest += strlen ("GError");
+      
+      *rest = g_strchug (*rest);
+      
+      if (**rest == '<')
+       {
+         (*rest)++;
+         
+         end = strchr (*rest, '>');
+         str = g_strndup (*rest, end - *rest);
+         type->errors = g_strsplit (str, ",", 0);
+         g_free (str);
+         
+         *rest = end + 1;
+       }
+    }
+  else 
+    {
+      type->tag = TYPE_TAG_INTERFACE;
+      type->is_interface = TRUE; 
+      start = *rest;
+
+      /* must be an interface type */
+      while (g_ascii_isalnum (**rest) || 
+            **rest == '.' || 
+            **rest == '-' || 
+            **rest == '_' ||
+            **rest == ':')
+       (*rest)++;
+
+      type->interface = g_strndup (start, *rest - start);
+
+      *rest = g_strchug (*rest);
+      if (**rest == '*')
+       {
+         type->is_pointer = TRUE;
+         (*rest)++;
+       }
+    }
+  
+  *rest = g_strchug (*rest);
+  if (g_str_has_prefix (*rest, "["))
+    {
+      GIdlNodeType *array;
+
+      array = (GIdlNodeType *)g_idl_node_new (G_IDL_NODE_TYPE);
+
+      array->tag = TYPE_TAG_ARRAY;
+      array->is_pointer = TRUE;
+      array->is_array = TRUE;
+      
+      array->parameter_type1 = type;
+
+      array->zero_terminated = FALSE;
+      array->has_length = FALSE;
+      array->length = 0;
+
+      if (!g_str_has_prefix (*rest, "[]"))
+       {
+         gchar *end, *str, **opts;
+         
+         end = strchr (*rest, ']');
+         str = g_strndup (*rest + 1, (end - *rest) - 1); 
+         opts = g_strsplit (str, ",", 0);
+         
+         *rest = end + 1;
+
+         for (i = 0; opts[i]; i++)
+           {
+             gchar **vals;
+             
+             vals = g_strsplit (opts[i], "=", 0);
+
+             if (strcmp (vals[0], "zero-terminated") == 0)
+               array->zero_terminated = (strcmp (vals[1], "1") == 0);
+             else if (strcmp (vals[0], "length") == 0)
+               {
+                 array->has_length = TRUE;
+                 array->length = atoi (vals[1]);
+               }
+
+             g_strfreev (vals);
+           }
+
+         g_free (str);
+         g_strfreev (opts);
+       }
+             
+      type = array;
+    }
+
+  return type;
+
+ error:
+  g_idl_node_free ((GIdlNode *)type);
+  
+  return NULL;
+}
+
+static GIdlNodeType *
+parse_type (const gchar *type)
+{
+  gchar *str;
+  gchar *rest;
+  GIdlNodeType *node;
+  
+  str = g_strdup (type);
+  node = parse_type_internal (str, &rest);
+  g_free (str);
+
+  return node;
+}
+
+static gboolean
+start_boxed (GMarkupParseContext *context,
+            const gchar         *element_name,
+            const gchar        **attribute_names,
+            const gchar        **attribute_values,
+            ParseContext        *ctx,
+            GError             **error)
+{
+  if (strcmp (element_name, "boxed") == 0 && 
+      ctx->state == STATE_NAMESPACE)
+    {
+      const gchar *name;
+      const gchar *typename;
+      const gchar *typeinit;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      typename = find_attribute ("type-name", attribute_names, attribute_values);
+      typeinit = find_attribute ("get-type", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (typename == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type-name");
+      else if (typeinit == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "get-type");
+      else
+       {
+         GIdlNodeBoxed *boxed;
+
+         boxed = (GIdlNodeBoxed *) g_idl_node_new (G_IDL_NODE_BOXED);
+         
+         ((GIdlNode *)boxed)->name = g_strdup (name);
+         boxed->gtype_name = g_strdup (typename);
+         boxed->gtype_init = g_strdup (typeinit);
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           boxed->deprecated = TRUE;
+         else
+           boxed->deprecated = FALSE;
+         
+         ctx->current_node = (GIdlNode *)boxed;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, boxed);
+         
+         ctx->state = STATE_BOXED;
+       }
+         
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+start_function (GMarkupParseContext *context,
+               const gchar         *element_name,
+               const gchar        **attribute_names,
+               const gchar        **attribute_values,
+               ParseContext        *ctx,
+               GError             **error)
+{
+  if ((ctx->state == STATE_NAMESPACE &&
+       (strcmp (element_name, "function") == 0 ||
+       strcmp (element_name, "callback") == 0)) ||
+      ((ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_INTERFACE ||
+       ctx->state == STATE_BOXED ||
+       ctx->state == STATE_STRUCT ||
+        ctx->state == STATE_UNION) &&
+       strcmp (element_name, "method") == 0) ||
+      ((ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_BOXED) &&
+       strcmp (element_name, "constructor") == 0))
+    {
+      const gchar *name;
+      const gchar *symbol;
+      const gchar *deprecated;
+      const gchar *type;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      symbol = find_attribute ("symbol", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      type = find_attribute ("type", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (strcmp (element_name, "callback") != 0 && symbol == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "symbol");
+      else
+       {
+         GIdlNodeFunction *function;
+         
+         function = (GIdlNodeFunction *) g_idl_node_new (G_IDL_NODE_FUNCTION);
+
+         ((GIdlNode *)function)->name = g_strdup (name);
+         function->symbol = g_strdup (symbol);
+         function->parameters = NULL;
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           function->deprecated = TRUE;
+         else
+           function->deprecated = FALSE;
+       
+         if (strcmp (element_name, "method") == 0 ||
+             strcmp (element_name, "constructor") == 0)
+           {
+             function->is_method = TRUE;
+
+             if (type && strcmp (type, "setter") == 0)
+               function->is_setter = TRUE;
+             else if (type && strcmp (type, "getter") == 0)
+               function->is_getter = TRUE;               
+
+             if (strcmp (element_name, "constructor") == 0)
+               function->is_constructor = TRUE;
+             else
+               function->is_constructor = FALSE;
+           }
+         else
+           {
+             function->is_method = FALSE;
+             function->is_setter = FALSE;
+             function->is_getter = FALSE;
+             function->is_constructor = FALSE;
+             if (strcmp (element_name, "callback") == 0)
+               ((GIdlNode *)function)->type = G_IDL_NODE_CALLBACK;
+           }
+         
+         if (ctx->current_node == NULL)
+           {
+             ctx->current_module->entries = 
+               g_list_append (ctx->current_module->entries, function);       
+           }
+         else
+           switch (ctx->current_node->type)
+             {
+             case G_IDL_NODE_INTERFACE:
+             case G_IDL_NODE_OBJECT:
+               {
+                 GIdlNodeInterface *iface;
+                 
+                 iface = (GIdlNodeInterface *)ctx->current_node;
+                 iface->members = g_list_append (iface->members, function);
+               }
+               break;
+             case G_IDL_NODE_BOXED:
+               {
+                 GIdlNodeBoxed *boxed;
+
+                 boxed = (GIdlNodeBoxed *)ctx->current_node;
+                 boxed->members = g_list_append (boxed->members, function);
+               }
+               break;
+             case G_IDL_NODE_STRUCT:
+               {
+                 GIdlNodeStruct *struct_;
+                 
+                 struct_ = (GIdlNodeStruct *)ctx->current_node;
+                 struct_->members = g_list_append (struct_->members, function);                }
+               break;
+             case G_IDL_NODE_UNION:
+               {
+                 GIdlNodeUnion *union_;
+                 
+                 union_ = (GIdlNodeUnion *)ctx->current_node;
+                 union_->members = g_list_append (union_->members, function);
+               }
+               break;
+             }
+         
+         ctx->current_node = (GIdlNode *)function;
+         ctx->state = STATE_FUNCTION;
+
+         return TRUE;
+       }
+    }
+
+  return FALSE;
+}
+
+static gboolean
+start_parameter (GMarkupParseContext *context,
+                const gchar         *element_name,
+                const gchar        **attribute_names,
+                const gchar        **attribute_values,
+                ParseContext        *ctx,
+                GError             **error)
+{
+  if (strcmp (element_name, "parameter") == 0 &&
+      ctx->state == STATE_PARAMETERS)
+    {
+      const gchar *type;
+      const gchar *name;
+      const gchar *direction;
+      const gchar *retval;
+      const gchar *dipper;
+      const gchar *optional;
+      const gchar *nullok;
+      const gchar *transfer;
+      
+      type = find_attribute ("type", attribute_names, attribute_values);
+      name = find_attribute ("name", attribute_names, attribute_values);
+      direction = find_attribute ("direction", attribute_names, attribute_values);
+      retval = find_attribute ("retval", attribute_names, attribute_values);
+      dipper = find_attribute ("dipper", attribute_names, attribute_values);
+      optional = find_attribute ("optional", attribute_names, attribute_values);
+      nullok = find_attribute ("null-ok", attribute_names, attribute_values);
+      transfer = find_attribute ("transfer", attribute_names, attribute_values);
+
+      if (type == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type");
+      else if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else
+       {
+         GIdlNodeParam *param;
+
+         param = (GIdlNodeParam *)g_idl_node_new (G_IDL_NODE_PARAM);
+         
+         if (direction && strcmp (direction, "out") == 0)
+           {
+             param->in = FALSE;
+             param->out = TRUE;
+           }
+         else if (direction && strcmp (direction, "inout") == 0)
+           {
+             param->in = TRUE;
+             param->out = TRUE;
+           }
+         else
+           {
+             param->in = TRUE;
+             param->out = FALSE;
+           }
+
+         if (retval && strcmp (retval, "1") == 0)
+           param->retval = TRUE;
+         else
+           param->retval = FALSE;
+
+         if (dipper && strcmp (dipper, "1") == 0)
+           param->dipper = TRUE;
+         else
+           param->dipper = FALSE;
+
+         if (optional && strcmp (optional, "1") == 0)
+           param->optional = TRUE;
+         else
+           param->optional = FALSE;
+
+         if (nullok && strcmp (nullok, "1") == 0)
+           param->null_ok = TRUE;
+         else
+           param->null_ok = FALSE;
+
+         if (transfer && strcmp (transfer, "none") == 0)
+           {
+             param->transfer = FALSE;
+             param->shallow_transfer = FALSE;
+           }
+         else if (transfer && strcmp (transfer, "shallow") == 0)
+           {
+             param->transfer = FALSE;
+             param->shallow_transfer = TRUE;
+           }
+         else
+           {
+             param->transfer = TRUE;
+             param->shallow_transfer = FALSE;
+           }
+         
+         ((GIdlNode *)param)->name = g_strdup (name);
+         param->type = parse_type (type);
+         
+         switch (ctx->current_node->type)
+           {
+           case G_IDL_NODE_FUNCTION:
+           case G_IDL_NODE_CALLBACK:
+             {
+               GIdlNodeFunction *func;
+
+               func = (GIdlNodeFunction *)ctx->current_node;
+               func->parameters = g_list_append (func->parameters, param);
+             }
+             break;
+           case G_IDL_NODE_SIGNAL:
+             {
+               GIdlNodeSignal *signal;
+
+               signal = (GIdlNodeSignal *)ctx->current_node;
+               signal->parameters = g_list_append (signal->parameters, param);
+             }
+             break;
+           case G_IDL_NODE_VFUNC:
+             {
+               GIdlNodeVFunc *vfunc;
+               
+               vfunc = (GIdlNodeVFunc *)ctx->current_node;
+               vfunc->parameters = g_list_append (vfunc->parameters, param);
+             }
+             break;
+           }
+       }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+start_field (GMarkupParseContext *context,
+            const gchar         *element_name,
+            const gchar        **attribute_names,
+            const gchar        **attribute_values,
+            ParseContext        *ctx,
+            GError             **error)
+{
+  if (strcmp (element_name, "field") == 0 &&
+      (ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_BOXED ||
+       ctx->state == STATE_STRUCT ||
+       ctx->state == STATE_UNION))
+    {
+      const gchar *name;
+      const gchar *type;
+      const gchar *readable;
+      const gchar *writable;
+      const gchar *bits;
+      const gchar *branch;
+      const gchar *offset;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      type = find_attribute ("type", attribute_names, attribute_values);
+      readable = find_attribute ("readable", attribute_names, attribute_values);
+      writable = find_attribute ("writable", attribute_names, attribute_values);
+      bits = find_attribute ("bits", attribute_names, attribute_values);
+      branch = find_attribute ("branch", attribute_names, attribute_values);
+      offset = find_attribute ("offset", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (type == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type");
+      else
+       {
+         GIdlNodeField *field;
+
+         field = (GIdlNodeField *)g_idl_node_new (G_IDL_NODE_FIELD);
+         ((GIdlNode *)field)->name = g_strdup (name);
+         if (readable && strcmp (readable, "1") == 0)
+           field->readable = TRUE;
+         else
+           field->readable = FALSE;
+         
+         if (writable && strcmp (writable, "1") == 0)
+           field->writable = TRUE;
+         else
+           field->writable = FALSE;
+         
+         if (bits)
+           field->bits = atoi (bits);
+         else
+           field->bits = 0;
+
+         if (offset)
+           field->offset = atoi (offset);
+         else
+           field->offset = 0;
+         
+         field->type = parse_type (type);
+         
+         switch (ctx->current_node->type)
+           {
+           case G_IDL_NODE_OBJECT:
+             {
+               GIdlNodeInterface *iface;
+
+               iface = (GIdlNodeInterface *)ctx->current_node;
+               iface->members = g_list_append (iface->members, field);
+             }
+             break;
+           case G_IDL_NODE_BOXED:
+             {
+               GIdlNodeBoxed *boxed;
+
+               boxed = (GIdlNodeBoxed *)ctx->current_node;
+               boxed->members = g_list_append (boxed->members, field);
+             }
+             break;
+           case G_IDL_NODE_STRUCT:
+             {
+               GIdlNodeStruct *struct_;
+
+               struct_ = (GIdlNodeStruct *)ctx->current_node;
+               struct_->members = g_list_append (struct_->members, field);
+             }
+             break;
+           case G_IDL_NODE_UNION:
+             {
+               GIdlNodeUnion *union_;
+
+               union_ = (GIdlNodeUnion *)ctx->current_node;
+               union_->members = g_list_append (union_->members, field);
+               if (branch)
+                 {
+                   GIdlNodeConstant *constant;
+                   
+                   constant = (GIdlNodeConstant *) g_idl_node_new (G_IDL_NODE_CONSTANT);
+                   ((GIdlNode *)constant)->name = g_strdup (name);
+                   constant->value = g_strdup (branch);          
+                   constant->type = union_->discriminator_type;
+                   constant->deprecated = FALSE;
+
+                   union_->discriminators = g_list_append (union_->discriminators, constant);
+                 }
+             }
+             break;
+           }
+       }
+      return TRUE;
+    }
+  
+  return FALSE;
+}
+
+static gboolean
+start_enum (GMarkupParseContext *context,
+            const gchar         *element_name,
+            const gchar        **attribute_names,
+            const gchar        **attribute_values,
+            ParseContext        *ctx,
+            GError             **error)
+{
+  if ((strcmp (element_name, "enum") == 0 && ctx->state == STATE_NAMESPACE) ||
+      (strcmp (element_name, "flags") == 0 && ctx->state == STATE_NAMESPACE))
+    {
+      const gchar *name;
+      const gchar *typename;
+      const gchar *typeinit;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      typename = find_attribute ("type-name", attribute_names, attribute_values);
+      typeinit = find_attribute ("get-type", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else 
+       {             
+         GIdlNodeEnum *enum_;
+         
+         if (strcmp (element_name, "enum") == 0)
+           enum_ = (GIdlNodeEnum *) g_idl_node_new (G_IDL_NODE_ENUM);
+         else
+           enum_ = (GIdlNodeEnum *) g_idl_node_new (G_IDL_NODE_FLAGS);
+         ((GIdlNode *)enum_)->name = g_strdup (name);
+         enum_->gtype_name = g_strdup (typename);
+         enum_->gtype_init = g_strdup (typeinit);
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           enum_->deprecated = TRUE;
+         else
+           enum_->deprecated = FALSE;
+
+         ctx->current_node = (GIdlNode *) enum_;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, enum_);              
+         
+         ctx->state = STATE_ENUM;
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_property (GMarkupParseContext *context,
+               const gchar         *element_name,
+               const gchar        **attribute_names,
+               const gchar        **attribute_values,
+               ParseContext        *ctx,
+               GError             **error)
+{
+  if (strcmp (element_name, "property") == 0 &&
+      (ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_INTERFACE))
+    {
+      const gchar *name;
+      const gchar *type;
+      const gchar *readable;
+      const gchar *writable;
+      const gchar *construct;
+      const gchar *construct_only;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      type = find_attribute ("type", attribute_names, attribute_values);
+      readable = find_attribute ("readable", attribute_names, attribute_values);
+      writable = find_attribute ("writable", attribute_names, attribute_values);
+      construct = find_attribute ("construct", attribute_names, attribute_values);
+      construct_only = find_attribute ("construct-only", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (type == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type");
+      else 
+       {             
+         GIdlNodeProperty *property;
+         GIdlNodeInterface *iface;
+         
+         property = (GIdlNodeProperty *) g_idl_node_new (G_IDL_NODE_PROPERTY);
+
+         ((GIdlNode *)property)->name = g_strdup (name);
+         
+         if (readable && strcmp (readable, "1") == 0)
+           property->readable = TRUE;
+         else
+           property->readable = FALSE;
+         if (writable && strcmp (writable, "1") == 0)
+           property->writable = TRUE;
+         else
+           property->writable = FALSE;
+         if (construct && strcmp (construct, "1") == 0)
+           property->construct = TRUE;
+         else
+           property->construct = FALSE;
+         if (construct_only && strcmp (construct_only, "1") == 0)
+           property->construct_only = TRUE;
+         else
+           property->construct_only = FALSE;
+
+         property->type = parse_type (type);
+         
+         iface = (GIdlNodeInterface *)ctx->current_node;
+         iface->members = g_list_append (iface->members, property);
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gint
+parse_value (const gchar *str)
+{
+  gchar *shift_op;
+ 
+  /* FIXME just a quick hack */
+  shift_op = strstr (str, "<<");
+
+  if (shift_op)
+    {
+      gint base, shift;
+
+      base = strtol (str, NULL, 10);
+      shift = strtol (shift_op + 3, NULL, 10);
+      
+      return base << shift;
+    }
+  else
+    return strtol (str, NULL, 10);
+
+  return 0;
+}
+
+static gboolean
+start_member (GMarkupParseContext *context,
+             const gchar         *element_name,
+             const gchar        **attribute_names,
+             const gchar        **attribute_values,
+             ParseContext        *ctx,
+             GError             **error)
+{
+  if (strcmp (element_name, "member") == 0 &&
+      ctx->state == STATE_ENUM)
+    {
+      const gchar *name;
+      const gchar *value;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      value = find_attribute ("value", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else 
+       {             
+         GIdlNodeEnum *enum_;
+         GIdlNodeValue *value_;
+
+         value_ = (GIdlNodeValue *) g_idl_node_new (G_IDL_NODE_VALUE);
+
+         ((GIdlNode *)value_)->name = g_strdup (name);
+         
+         value_->value = parse_value (value);
+         
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           value_->deprecated = TRUE;
+         else
+           value_->deprecated = FALSE;
+
+         enum_ = (GIdlNodeEnum *)ctx->current_node;
+         enum_->values = g_list_append (enum_->values, value_);
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_constant (GMarkupParseContext *context,
+               const gchar         *element_name,
+               const gchar        **attribute_names,
+               const gchar        **attribute_values,
+               ParseContext        *ctx,
+               GError             **error)
+{
+  if (strcmp (element_name, "constant") == 0 &&
+      (ctx->state == STATE_NAMESPACE ||
+       ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_INTERFACE))
+    {
+      const gchar *name;
+      const gchar *type;
+      const gchar *value;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      type = find_attribute ("type", attribute_names, attribute_values);
+      value = find_attribute ("value", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (type == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type");
+      else if (value == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "value");
+      else 
+       {             
+         GIdlNodeConstant *constant;
+
+         constant = (GIdlNodeConstant *) g_idl_node_new (G_IDL_NODE_CONSTANT);
+
+         ((GIdlNode *)constant)->name = g_strdup (name);
+         constant->value = g_strdup (value);
+         
+         constant->type = parse_type (type);
+
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           constant->deprecated = TRUE;
+         else
+           constant->deprecated = FALSE;
+
+         if (ctx->state == STATE_NAMESPACE)
+           {
+             ctx->current_node = (GIdlNode *) constant;
+             ctx->current_module->entries = 
+               g_list_append (ctx->current_module->entries, constant);
+           }
+         else
+           {
+             GIdlNodeInterface *iface;
+
+             iface = (GIdlNodeInterface *)ctx->current_node;
+             iface->members = g_list_append (iface->members, constant);
+           }
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_errordomain (GMarkupParseContext *context,
+                  const gchar         *element_name,
+                  const gchar        **attribute_names,
+                  const gchar        **attribute_values,
+                  ParseContext        *ctx,
+                  GError             **error)
+{
+  if (strcmp (element_name, "errordomain") == 0 &&
+      ctx->state == STATE_NAMESPACE)
+    {
+      const gchar *name;
+      const gchar *getquark;
+      const gchar *codes;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      getquark = find_attribute ("get-quark", attribute_names, attribute_values);
+      codes = find_attribute ("codes", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (getquark == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "getquark");
+      else if (codes == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "codes");
+      else 
+       {             
+         GIdlNodeErrorDomain *domain;
+
+         domain = (GIdlNodeErrorDomain *) g_idl_node_new (G_IDL_NODE_ERROR_DOMAIN);
+
+         ((GIdlNode *)domain)->name = g_strdup (name);
+         domain->getquark = g_strdup (getquark);
+         domain->codes = g_strdup (codes);
+
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           domain->deprecated = TRUE;
+         else
+           domain->deprecated = FALSE;
+
+         ctx->current_node = (GIdlNode *) domain;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, domain);
+
+         ctx->state = STATE_ERRORDOMAIN;
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_interface (GMarkupParseContext *context,
+                const gchar         *element_name,
+                const gchar        **attribute_names,
+                const gchar        **attribute_values,
+                ParseContext        *ctx,
+                GError             **error)
+{
+  if (strcmp (element_name, "interface") == 0 &&
+      ctx->state == STATE_NAMESPACE)
+    {
+      const gchar *name;
+      const gchar *typename;
+      const gchar *typeinit;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      typename = find_attribute ("type-name", attribute_names, attribute_values);
+      typeinit = find_attribute ("get-type", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (typename == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type-name");
+      else if (typeinit == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "get-type");
+      else
+       {
+         GIdlNodeInterface *iface;
+
+         iface = (GIdlNodeInterface *) g_idl_node_new (G_IDL_NODE_INTERFACE);
+         ((GIdlNode *)iface)->name = g_strdup (name);
+         iface->gtype_name = g_strdup (typename);
+         iface->gtype_init = g_strdup (typeinit);
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           iface->deprecated = TRUE;
+         else
+           iface->deprecated = FALSE;
+         
+         ctx->current_node = (GIdlNode *) iface;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, iface);              
+         
+         ctx->state = STATE_INTERFACE;
+         
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_object (GMarkupParseContext *context,
+             const gchar         *element_name,
+             const gchar        **attribute_names,
+             const gchar        **attribute_values,
+             ParseContext        *ctx,
+             GError             **error)
+{
+  if (strcmp (element_name, "object") == 0 &&
+      ctx->state == STATE_NAMESPACE)
+    {
+      const gchar *name;
+      const gchar *parent;
+      const gchar *typename;
+      const gchar *typeinit;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      parent = find_attribute ("parent", attribute_names, attribute_values);
+      typename = find_attribute ("type-name", attribute_names, attribute_values);
+      typeinit = find_attribute ("get-type", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (typename == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type-name");
+      else if (typeinit == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "get-type");
+      else
+       {
+         GIdlNodeInterface *iface;
+
+         iface = (GIdlNodeInterface *) g_idl_node_new (G_IDL_NODE_OBJECT);
+         ((GIdlNode *)iface)->name = g_strdup (name);
+         iface->gtype_name = g_strdup (typename);
+         iface->gtype_init = g_strdup (typeinit);
+         iface->parent = g_strdup (parent);
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           iface->deprecated = TRUE;
+         else
+           iface->deprecated = FALSE;
+         
+         ctx->current_node = (GIdlNode *) iface;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, iface);              
+         
+         ctx->state = STATE_OBJECT;
+       }
+      
+      return TRUE;
+    }
+  return  FALSE;
+}
+
+static gboolean
+start_return_type (GMarkupParseContext *context,
+                  const gchar         *element_name,
+                  const gchar        **attribute_names,
+                  const gchar        **attribute_values,
+                  ParseContext       *ctx,
+                  GError             **error)
+{
+  if (strcmp (element_name, "return-type") == 0 &&
+      ctx->state == STATE_FUNCTION)
+    {
+      const gchar *type;
+      const gchar *nullok;
+      const gchar *transfer;
+      
+      type = find_attribute ("type", attribute_names, attribute_values);
+      nullok = find_attribute ("null-ok", attribute_names, attribute_values);
+      transfer = find_attribute ("transfer", attribute_names, attribute_values);
+      if (type == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type");
+      else
+       {
+         GIdlNodeParam *param;
+
+         param = (GIdlNodeParam *)g_idl_node_new (G_IDL_NODE_PARAM);
+         param->in = FALSE;
+         param->out = FALSE;
+         param->retval = TRUE;
+         if (nullok && strcmp (nullok, "1") == 0)
+           param->null_ok = TRUE;
+         else
+           param->null_ok = FALSE;
+         if (transfer && strcmp (transfer, "none") == 0)
+           {
+             param->transfer = FALSE;
+             param->shallow_transfer = FALSE;
+           }
+         else if (transfer && strcmp (transfer, "shallow") == 0)
+           {
+             param->transfer = FALSE;
+             param->shallow_transfer = TRUE;
+           }
+         else
+           {
+             param->transfer = TRUE;
+             param->shallow_transfer = FALSE;
+           }
+         
+         param->type = parse_type (type);
+         
+         switch (ctx->current_node->type)
+           {
+           case G_IDL_NODE_FUNCTION:
+           case G_IDL_NODE_CALLBACK:
+             {
+               GIdlNodeFunction *func = (GIdlNodeFunction *)ctx->current_node;
+               func->result = param;
+             }
+             break;
+           case G_IDL_NODE_SIGNAL:
+             {
+               GIdlNodeSignal *signal = (GIdlNodeSignal *)ctx->current_node;
+               signal->result = param;
+             }
+             break;
+           case G_IDL_NODE_VFUNC:
+             {
+               GIdlNodeVFunc *vfunc = (GIdlNodeVFunc *)ctx->current_node;
+               vfunc->result = param;
+             }
+             break;
+           }
+       }
+      
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+start_signal (GMarkupParseContext *context,
+             const gchar         *element_name,
+             const gchar        **attribute_names,
+             const gchar        **attribute_values,
+             ParseContext       *ctx,
+             GError             **error)
+{
+  if (strcmp (element_name, "signal") == 0 && 
+      (ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_INTERFACE))
+    {
+      const gchar *name;
+      const gchar *when;
+      const gchar *no_recurse;
+      const gchar *detailed;
+      const gchar *action;
+      const gchar *no_hooks;
+      const gchar *has_class_closure;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      when = find_attribute ("when", attribute_names, attribute_values);
+      no_recurse = find_attribute ("no-recurse", attribute_names, attribute_values);
+      detailed = find_attribute ("detailed", attribute_names, attribute_values);
+      action = find_attribute ("action", attribute_names, attribute_values);
+      no_hooks = find_attribute ("no-hooks", attribute_names, attribute_values);
+      has_class_closure = find_attribute ("has-class-closure", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else if (when == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "when");
+      else
+       {
+         GIdlNodeInterface *iface;
+         GIdlNodeSignal *signal;
+
+         signal = (GIdlNodeSignal *)g_idl_node_new (G_IDL_NODE_SIGNAL);
+         
+         ((GIdlNode *)signal)->name = g_strdup (name);
+         
+         signal->run_first = FALSE;
+         signal->run_last = FALSE;
+         signal->run_cleanup = FALSE;
+         if (strcmp (when, "FIRST") == 0)
+           signal->run_first = TRUE;
+         else if (strcmp (when, "LAST") == 0)
+           signal->run_last = TRUE;
+         else 
+           signal->run_cleanup = TRUE;
+         
+         if (no_recurse && strcmp (no_recurse, "1") == 0)
+           signal->no_recurse = TRUE;
+         else
+           signal->no_recurse = FALSE;
+         if (detailed && strcmp (detailed, "1") == 0)
+           signal->detailed = TRUE;
+         else
+           signal->detailed = FALSE;
+         if (action && strcmp (action, "1") == 0)
+           signal->action = TRUE;
+         else
+           signal->action = FALSE;
+         if (no_hooks && strcmp (no_hooks, "1") == 0)
+           signal->no_hooks = TRUE;
+         else
+           signal->no_hooks = FALSE;
+         if (has_class_closure && strcmp (has_class_closure, "1") == 0)
+           signal->has_class_closure = TRUE;
+         else
+           signal->has_class_closure = FALSE;
+
+         iface = (GIdlNodeInterface *)ctx->current_node;
+         iface->members = g_list_append (iface->members, signal);
+
+         ctx->current_node = (GIdlNode *)signal;
+         ctx->state = STATE_FUNCTION;
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_vfunc (GMarkupParseContext *context,
+            const gchar         *element_name,
+            const gchar        **attribute_names,
+            const gchar        **attribute_values,
+            ParseContext       *ctx,
+            GError             **error)
+{
+  if (strcmp (element_name, "vfunc") == 0 && 
+      (ctx->state == STATE_OBJECT ||
+       ctx->state == STATE_INTERFACE))
+    {
+      const gchar *name;
+      const gchar *must_chain_up;
+      const gchar *override;
+      const gchar *is_class_closure;
+      const gchar *offset;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      must_chain_up = find_attribute ("must-chain-up", attribute_names, attribute_values);       
+      override = find_attribute ("override", attribute_names, attribute_values);
+      is_class_closure = find_attribute ("is-class-closure", attribute_names, attribute_values);
+      offset = find_attribute ("offset", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else
+       {
+         GIdlNodeInterface *iface;
+         GIdlNodeVFunc *vfunc;
+
+         vfunc = (GIdlNodeVFunc *)g_idl_node_new (G_IDL_NODE_VFUNC);
+         
+         ((GIdlNode *)vfunc)->name = g_strdup (name);
+
+         if (must_chain_up && strcmp (must_chain_up, "1") == 0)
+           vfunc->must_chain_up = TRUE;
+         else
+           vfunc->must_chain_up = FALSE;
+
+         if (override && strcmp (override, "always") == 0)
+           {
+             vfunc->must_be_implemented = TRUE;
+             vfunc->must_not_be_implemented = FALSE;
+           }
+         else if (override && strcmp (override, "never") == 0)
+           {
+             vfunc->must_be_implemented = FALSE;
+             vfunc->must_not_be_implemented = TRUE;
+           }
+         else
+           {
+             vfunc->must_be_implemented = FALSE;
+             vfunc->must_not_be_implemented = FALSE;
+           }
+         
+         if (is_class_closure && strcmp (is_class_closure, "1") == 0)
+           vfunc->is_class_closure = TRUE;
+         else
+           vfunc->is_class_closure = FALSE;
+         
+         if (offset)
+           vfunc->offset = atoi (offset);
+         else
+           vfunc->offset = 0;
+
+         iface = (GIdlNodeInterface *)ctx->current_node;
+         iface->members = g_list_append (iface->members, vfunc);
+
+         ctx->current_node = (GIdlNode *)vfunc;
+         ctx->state = STATE_FUNCTION;
+       }
+      
+      return TRUE;
+    }
+  return FALSE;
+}
+
+
+static gboolean
+start_struct (GMarkupParseContext *context,
+             const gchar         *element_name,
+             const gchar        **attribute_names,
+             const gchar        **attribute_values,
+             ParseContext       *ctx,
+             GError             **error)
+{
+  if (strcmp (element_name, "struct") == 0 && 
+      ctx->state == STATE_NAMESPACE)
+    {
+      const gchar *name;
+      const gchar *deprecated;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else
+       {
+         GIdlNodeStruct *struct_;
+
+         struct_ = (GIdlNodeStruct *) g_idl_node_new (G_IDL_NODE_STRUCT);
+         
+         ((GIdlNode *)struct_)->name = g_strdup (name);
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           struct_->deprecated = TRUE;
+         else
+           struct_->deprecated = FALSE;
+
+         ctx->current_node = (GIdlNode *)struct_;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, struct_);
+         
+         ctx->state = STATE_STRUCT;
+           }
+      return TRUE;
+    }
+  return FALSE;
+}
+  
+
+static gboolean
+start_union (GMarkupParseContext *context,
+            const gchar         *element_name,
+            const gchar        **attribute_names,
+            const gchar        **attribute_values,
+            ParseContext       *ctx,
+            GError             **error)
+{
+  if (strcmp (element_name, "union") == 0 && 
+      ctx->state == STATE_NAMESPACE)
+    {
+      const gchar *name;
+      const gchar *deprecated;
+      const gchar *typename;
+      const gchar *typeinit;
+      
+      name = find_attribute ("name", attribute_names, attribute_values);
+      deprecated = find_attribute ("deprecated", attribute_names, attribute_values);
+      typename = find_attribute ("type-name", attribute_names, attribute_values);
+      typeinit = find_attribute ("get-type", attribute_names, attribute_values);
+      
+      if (name == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "name");
+      else
+       {
+         GIdlNodeUnion *union_;
+
+         union_ = (GIdlNodeUnion *) g_idl_node_new (G_IDL_NODE_UNION);
+         
+         ((GIdlNode *)union_)->name = g_strdup (name);
+         union_->gtype_name = g_strdup (typename);
+         union_->gtype_init = g_strdup (typeinit);
+         if (deprecated && strcmp (deprecated, "1") == 0)
+           union_->deprecated = TRUE;
+         else
+           union_->deprecated = FALSE;
+
+         ctx->current_node = (GIdlNode *)union_;
+         ctx->current_module->entries = 
+           g_list_append (ctx->current_module->entries, union_);
+         
+         ctx->state = STATE_UNION;
+       }
+      return TRUE;
+    }
+  return FALSE;
+}
+
+static gboolean
+start_discriminator (GMarkupParseContext *context,
+                    const gchar         *element_name,
+                    const gchar        **attribute_names,
+                    const gchar        **attribute_values,
+                    ParseContext       *ctx,
+                    GError             **error)
+{
+  if (strcmp (element_name, "discriminator") == 0 &&
+      ctx->state == STATE_UNION)
+    {
+      const gchar *type;
+      const gchar *offset;
+      
+      type = find_attribute ("type", attribute_names, attribute_values);
+      offset = find_attribute ("offset", attribute_names, attribute_values);
+      if (type == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "type");
+      else if (offset == NULL)
+       MISSING_ATTRIBUTE (error, element_name, "offset");
+       {
+         ((GIdlNodeUnion *)ctx->current_node)->discriminator_type 
+           = parse_type (type);
+         ((GIdlNodeUnion *)ctx->current_node)->discriminator_offset 
+           = atoi (offset);
+       }
+      
+      return TRUE;
+    }
+
+  return FALSE;
+}
+  
+static void
+start_element_handler (GMarkupParseContext *context,
+                      const gchar         *element_name,
+                      const gchar        **attribute_names,
+                      const gchar        **attribute_values,
+                      gpointer             user_data,
+                      GError             **error)
+{
+  ParseContext *ctx = user_data;
+  gint i, line_number, char_number;
+
+  switch (element_name[0])
+    {
+    case 'a':
+      if (strcmp (element_name, "api") == 0 && ctx->state == STATE_START)
+       {
+         const gchar *version;
+
+         version = find_attribute ("version", attribute_names, attribute_values);
+         
+         if (version == NULL)
+           MISSING_ATTRIBUTE (error, element_name, "version");
+         else if (strcmp (version, "1.0") != 0)
+           g_set_error (error,
+                        G_MARKUP_ERROR,
+                        G_MARKUP_ERROR_INVALID_CONTENT,
+                        "Unsupported version '%s'",
+                        version);
+         else
+           ctx->state = STATE_ROOT;
+         
+         goto out;
+       }
+      break;
+
+    case 'b':
+      if (start_boxed (context, element_name,
+                      attribute_names, attribute_values,
+                      ctx, error))
+       goto out;
+      break;
+
+    case 'c':
+      if (start_function (context, element_name, 
+                         attribute_names, attribute_values,
+                         ctx, error))
+       goto out;
+      else if (start_constant (context, element_name,
+                              attribute_names, attribute_values,
+                              ctx, error))
+       goto out;
+      break;
+
+    case 'd':
+      if (start_discriminator (context, element_name, 
+                              attribute_names, attribute_values,
+                              ctx, error))
+       goto out;
+      break;
+
+    case 'e':
+      if (start_enum (context, element_name, 
+                     attribute_names, attribute_values,
+                     ctx, error))
+       goto out;
+      else if (start_errordomain (context, element_name, 
+                     attribute_names, attribute_values,
+                     ctx, error))
+       goto out;
+      break;
+
+    case 'f':
+      if (start_function (context, element_name, 
+                         attribute_names, attribute_values,
+                         ctx, error))
+       goto out;
+      else if (start_field (context, element_name, 
+                           attribute_names, attribute_values,
+                           ctx, error))
+       goto out;
+      else if (start_enum (context, element_name, 
+                          attribute_names, attribute_values,
+                          ctx, error))
+       goto out;
+      
+      break;
+
+    case 'i':
+      if (start_interface (context, element_name, 
+                          attribute_names, attribute_values,
+                          ctx, error))
+       goto out;
+      if (strcmp (element_name, "implements") == 0 &&
+         ctx->state == STATE_OBJECT)
+       {
+         ctx->state = STATE_IMPLEMENTS;
+
+         goto out;
+       }
+      else if (strcmp (element_name, "interface") == 0 &&
+              ctx->state == STATE_IMPLEMENTS)
+       {
+         const gchar *name;
+
+         name = find_attribute ("name", attribute_names, attribute_values);
+
+         if (name == NULL)
+           MISSING_ATTRIBUTE (error, element_name, "name");
+         else
+           {  
+             GIdlNodeInterface *iface;
+
+             iface = (GIdlNodeInterface *)ctx->current_node;
+             iface ->interfaces = g_list_append (iface->interfaces, g_strdup (name));
+           }
+
+         goto out;
+       }
+      else if (strcmp (element_name, "interface") == 0 &&
+              ctx->state == STATE_REQUIRES)
+       {
+         const gchar *name;
+
+         name = find_attribute ("name", attribute_names, attribute_values);
+
+         if (name == NULL)
+           MISSING_ATTRIBUTE (error, element_name, "name");
+         else
+           {  
+             GIdlNodeInterface *iface;
+
+             iface = (GIdlNodeInterface *)ctx->current_node;
+             iface ->prerequisites = g_list_append (iface->prerequisites, g_strdup (name));
+           }
+
+         goto out;
+       }
+      break;
+
+    case 'm':
+      if (start_function (context, element_name, 
+                         attribute_names, attribute_values,
+                         ctx, error))
+       goto out;
+      else if (start_member (context, element_name, 
+                         attribute_names, attribute_values,
+                         ctx, error))
+       goto out;
+      break;
+
+    case 'n':
+      if (strcmp (element_name, "namespace") == 0 && ctx->state == STATE_ROOT)
+       {
+         const gchar *name;
+         
+         name = find_attribute ("name", attribute_names, attribute_values);
+
+         if (name == NULL)
+           MISSING_ATTRIBUTE (error, element_name, "name");
+         else
+           {
+             ctx->current_module = g_idl_module_new (name);
+             ctx->modules = g_list_append (ctx->modules, ctx->current_module);
+
+             ctx->state = STATE_NAMESPACE;
+           }
+
+         goto out;
+       }
+      break;
+
+    case 'o':
+      if (start_object (context, element_name, 
+                       attribute_names, attribute_values,
+                       ctx, error))
+       goto out;
+      else if (strcmp (element_name, "object") == 0 &&
+              ctx->state == STATE_REQUIRES)
+       {
+         const gchar *name;
+
+         name = find_attribute ("name", attribute_names, attribute_values);
+
+         if (name == NULL)
+           MISSING_ATTRIBUTE (error, element_name, "name");
+         else
+           {  
+             GIdlNodeInterface *iface;
+
+             iface = (GIdlNodeInterface *)ctx->current_node;
+             iface ->prerequisites = g_list_append (iface->prerequisites, g_strdup (name));
+           }
+
+         goto out;
+       }
+      break;
+
+    case 'p':
+      if (start_property (context, element_name,
+                         attribute_names, attribute_values,
+                         ctx, error))
+       goto out;
+      else if (strcmp (element_name, "parameters") == 0 &&
+         ctx->state == STATE_FUNCTION)
+       {
+         ctx->state = STATE_PARAMETERS;
+
+         goto out;
+       }
+      else if (start_parameter (context, element_name,
+                               attribute_names, attribute_values,
+                               ctx, error))
+       goto out;
+
+      break;
+
+    case 'r':
+      if (start_return_type (context, element_name,
+                            attribute_names, attribute_values,
+                            ctx, error))
+       goto out;      
+      else if (strcmp (element_name, "requires") == 0 &&
+              ctx->state == STATE_INTERFACE)
+       {
+         ctx->state = STATE_REQUIRES;
+         
+         goto out;
+       }
+
+      break;
+
+    case 's':
+      if (start_signal (context, element_name,
+                       attribute_names, attribute_values,
+                       ctx, error))
+       goto out;      
+      else if (start_struct (context, element_name,
+                            attribute_names, attribute_values,
+                            ctx, error))
+       goto out;      
+
+      break;
+
+    case 'u':
+      if (start_union (context, element_name,
+                      attribute_names, attribute_values,
+                      ctx, error))
+       goto out;
+      break;
+
+    case 'v':
+      if (start_vfunc (context, element_name,
+                      attribute_names, attribute_values,
+                      ctx, error))
+       goto out;      
+      break;
+    }
+
+  g_markup_parse_context_get_position (context, &line_number, &char_number);
+
+  g_set_error (error,
+              G_MARKUP_ERROR,
+              G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+              "Unexpected start tag '%s' on line %d char %d",
+              element_name,
+              line_number, char_number);
+  
+ out: ;
+      
+}
+
+static void
+end_element_handler (GMarkupParseContext *context,
+                    const gchar         *element_name,
+                    gpointer             user_data,
+                    GError             **error)
+{
+  ParseContext *ctx = user_data;
+
+  switch (ctx->state)
+    {
+    case STATE_START:
+    case STATE_END:
+      /* no need to GError here, GMarkup already catches this */
+      break;
+
+    case STATE_ROOT:
+      ctx->state = STATE_END;
+      break;
+
+    case STATE_NAMESPACE:
+      if (strcmp (element_name, "namespace") == 0)
+       {
+          ctx->current_module = NULL;
+          ctx->state = STATE_ROOT;
+        }
+      break;
+
+    case STATE_FUNCTION:
+      if (strcmp (element_name, "return-type") == 0)
+       /* do nothing */ ;
+       
+      else if (ctx->current_node == g_list_last (ctx->current_module->entries)->data)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      else 
+       { 
+         ctx->current_node = g_list_last (ctx->current_module->entries)->data;
+         if (ctx->current_node->type == G_IDL_NODE_INTERFACE)
+           ctx->state = STATE_INTERFACE;
+         else if (ctx->current_node->type == G_IDL_NODE_OBJECT)
+           ctx->state = STATE_OBJECT;
+         else if (ctx->current_node->type == G_IDL_NODE_BOXED)
+           ctx->state = STATE_BOXED;
+         else if (ctx->current_node->type == G_IDL_NODE_STRUCT)
+           ctx->state = STATE_STRUCT;
+         else if (ctx->current_node->type == G_IDL_NODE_UNION)
+           ctx->state = STATE_UNION;
+       }
+      break;
+
+    case STATE_OBJECT:
+      if (strcmp (element_name, "object") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+
+    case STATE_ERRORDOMAIN:
+      if (strcmp (element_name, "errordomain") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+
+    case STATE_INTERFACE:
+      if (strcmp (element_name, "interface") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+
+    case STATE_ENUM:
+      if (strcmp (element_name, "enum") == 0 ||
+         strcmp (element_name, "flags") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+
+    case STATE_BOXED:
+      if (strcmp (element_name, "boxed") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+
+    case STATE_STRUCT:
+      if (strcmp (element_name, "struct") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+    case STATE_UNION:
+      if (strcmp (element_name, "union") == 0)
+       {
+         ctx->current_node = NULL;
+         ctx->state = STATE_NAMESPACE;
+       }
+      break;
+
+    case STATE_IMPLEMENTS:
+      if (strcmp (element_name, "implements") == 0)
+        ctx->state = STATE_OBJECT;
+      break;
+    case STATE_REQUIRES:
+      ctx->state = STATE_INTERFACE;
+      break;
+    case STATE_PARAMETERS:
+      if (strcmp (element_name, "parameters") == 0)
+       ctx->state = STATE_FUNCTION;
+      break;
+    default:
+      g_error ("Unhandled state %d in end_element_handler\n", ctx->state);
+    }
+}
+
+static void 
+text_handler (GMarkupParseContext *context,
+             const gchar         *text,
+             gsize                text_len,  
+             gpointer             user_data,
+             GError             **error)
+{
+  /* FIXME warn about non-whitespace text */
+}
+
+static void
+cleanup (GMarkupParseContext *context,
+        GError              *error,
+        gpointer             user_data)
+{
+  ParseContext *ctx = user_data;
+  GList *m;
+
+  for (m = ctx->modules; m; m = m->next)
+    g_idl_module_free (m->data);
+  g_list_free (ctx->modules);
+  ctx->modules = NULL;
+  
+  ctx->current_module = NULL;
+}
+
+static GMarkupParser parser = 
+{
+  start_element_handler,
+  end_element_handler,
+  text_handler,
+  NULL,
+  cleanup
+};
+
+GList * 
+g_idl_parse_string (const gchar  *buffer, 
+                   gssize        length,
+                    GError      **error)
+{
+  ParseContext ctx = { 0 };
+  GMarkupParseContext *context;
+
+  ctx.state = STATE_START;
+  
+  context = g_markup_parse_context_new (&parser, 0, &ctx, NULL);
+  if (!g_markup_parse_context_parse (context, buffer, length, error))
+    goto out;
+
+  if (!g_markup_parse_context_end_parse (context, error))
+    goto out;
+
+ out:
+  
+  g_markup_parse_context_free (context);
+  
+  return ctx.modules;
+}
+
+GList *
+g_idl_parse_file (const gchar  *filename,
+                 GError      **error)
+{
+  gchar *buffer;
+  gsize length;
+  GList *modules;
+
+  if (!g_file_get_contents (filename, &buffer, &length, error))
+    return NULL;
+  
+  modules = g_idl_parse_string (buffer, length, error);
+
+  g_free (buffer);
+
+  return modules;
+}
+
+

diff --git a/vapigen/gobject-introspection/gidlparser.h b/vapigen/gobject-introspection/gidlparser.h
new file mode 100644 (file)
index 0000000..2d71aaa
--- /dev/null
+++ b/vapigen/gobject-introspection/gidlparser.h
@@ -0,0 +1,38 @@
+/* GObject introspection: A parser for the XML IDL format
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_IDL_PARSER_H__
+#define __G_IDL_PARSER_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+
+GList *g_idl_parse_string (const gchar  *buffer, 
+                          gssize        length,
+                          GError      **error);
+GList *g_idl_parse_file   (const gchar  *filename,
+                          GError      **error);
+
+
+G_END_DECLS
+
+#endif  /* __G_IDL_PARSER_H__ */

diff --git a/vapigen/gobject-introspection/gmetadata.h b/vapigen/gobject-introspection/gmetadata.h
new file mode 100644 (file)
index 0000000..7ca390c
--- /dev/null
+++ b/vapigen/gobject-introspection/gmetadata.h
@@ -0,0 +1,539 @@
+/* GObject introspection: struct definitions for the binary
+ * metadata format, validation
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_METADATA_H__
+#define __G_METADATA_H__
+
+G_BEGIN_DECLS
+
+#define G_IDL_MAGIC "GOBJ\nMETADATA\r\n\032"
+
+enum 
+{
+  BLOB_TYPE_INVALID,
+  BLOB_TYPE_FUNCTION,
+  BLOB_TYPE_CALLBACK,
+  BLOB_TYPE_STRUCT,
+  BLOB_TYPE_BOXED,
+  BLOB_TYPE_ENUM,
+  BLOB_TYPE_FLAGS,
+  BLOB_TYPE_OBJECT,
+  BLOB_TYPE_INTERFACE,
+  BLOB_TYPE_CONSTANT,
+  BLOB_TYPE_ERROR_DOMAIN,
+  BLOB_TYPE_UNION
+};
+
+typedef struct
+{
+  gchar   magic[16];
+  guint8  major_version;
+  guint8  minor_version;
+  guint16 reserved;
+  guint16 n_entries;
+  guint16 n_local_entries;
+  guint32 directory;
+  guint32 n_annotations;
+  guint32 annotations;
+
+  guint32 size;
+  guint32 namespace;
+
+  guint16 entry_blob_size;
+  guint16 function_blob_size;
+  guint16 callback_blob_size;
+  guint16 signal_blob_size;
+  guint16 vfunc_blob_size;
+  guint16 arg_blob_size;
+  guint16 property_blob_size;
+  guint16 field_blob_size;
+  guint16 value_blob_size;
+  guint16 annotation_blob_size;
+  guint16 constant_blob_size;
+  guint16 error_domain_blob_size;
+
+  guint16 signature_blob_size;
+  guint16 enum_blob_size;
+  guint16 struct_blob_size;
+  guint16 object_blob_size;
+  guint16 interface_blob_size;
+  guint16 union_blob_size;
+  
+  guint16 padding;
+} Header;
+
+typedef struct
+{
+  guint16 blob_type;
+
+  guint   local    : 1;
+  guint   reserved :15;
+
+  guint32 name;
+  guint32 offset;
+} DirEntry;
+
+
+#define TYPE_POINTER_MASK 1 << 7
+#define TYPE_TAG_MASK         63
+
+typedef enum 
+{
+  TYPE_TAG_VOID      =  0,
+  TYPE_TAG_BOOLEAN   =  1,
+  TYPE_TAG_INT8      =  2,
+  TYPE_TAG_UINT8     =  3,
+  TYPE_TAG_INT16     =  4,
+  TYPE_TAG_UINT16    =  5,  
+  TYPE_TAG_INT32     =  6,
+  TYPE_TAG_UINT32    =  7,
+  TYPE_TAG_INT64     =  8,
+  TYPE_TAG_UINT64    =  9,
+  TYPE_TAG_INT       = 10,
+  TYPE_TAG_UINT      = 11,
+  TYPE_TAG_LONG      = 12,
+  TYPE_TAG_ULONG     = 13,
+  TYPE_TAG_SSIZE     = 14,
+  TYPE_TAG_SIZE      = 15,
+  TYPE_TAG_FLOAT     = 16,
+  TYPE_TAG_DOUBLE    = 17,
+  TYPE_TAG_UTF8      = 18,
+  TYPE_TAG_FILENAME  = 19,
+  TYPE_TAG_ARRAY     = 20,
+  TYPE_TAG_INTERFACE = 21,
+  TYPE_TAG_LIST      = 22,
+  TYPE_TAG_SLIST     = 23,
+  TYPE_TAG_HASH      = 24,
+  TYPE_TAG_ERROR     = 25
+} TypeTag;
+
+typedef union
+{
+  struct 
+  {
+    guint reserved   : 8;
+    guint reserved2  :16;
+    guint pointer    : 1;
+    guint reserved3  : 2;
+    guint tag        : 5;    
+  };
+  guint32    offset;
+} SimpleTypeBlob;
+
+
+typedef struct
+{
+  guint32        name;
+
+  guint          in                           : 1;
+  guint          out                          : 1;
+  guint          dipper                       : 1;
+  guint          null_ok                      : 1;
+  guint          optional                     : 1;
+  guint          transfer_ownership           : 1;
+  guint          transfer_container_ownership : 1;
+  guint          return_value                 : 1;
+  guint          reserved                     :24;
+
+  SimpleTypeBlob arg_type;
+} ArgBlob;
+
+typedef struct 
+{
+  SimpleTypeBlob return_type;
+
+  guint          may_return_null              : 1;
+  guint          caller_owns_return_value     : 1;
+  guint          caller_owns_return_container : 1;
+  guint          reserved                     :13;
+
+  guint16        n_arguments;
+
+  ArgBlob        arguments[];
+} SignatureBlob;
+
+typedef struct
+{
+  guint16 blob_type;  /* 1 */
+
+  guint   deprecated     : 1;
+  guint   reserved       :15;
+
+  guint32 name;
+} CommonBlob;
+
+typedef struct 
+{
+  guint16 blob_type;  /* 1 */
+
+  guint   deprecated     : 1;
+  guint   setter         : 1; 
+  guint   getter         : 1;
+  guint   constructor    : 1;
+  guint   wraps_vfunc    : 1;
+  guint   reserved       : 1;
+  guint   index          :10;
+
+  guint32 name;
+  guint32 symbol;
+  guint32 signature;
+} FunctionBlob;
+
+typedef struct 
+{
+  guint16 blob_type;  /* 2 */
+
+  guint   deprecated     : 1;
+  guint   reserved       :15;
+
+  guint32 name;
+  guint32 signature;
+} CallbackBlob;
+
+typedef struct 
+{
+  guint pointer    :1;
+  guint reserved   :2;
+  guint tag        :5;    
+  guint8     reserved2;
+  guint16    interface;  
+} InterfaceTypeBlob;
+
+typedef struct
+{
+  guint pointer    :1;
+  guint reserved   :2;
+  guint tag        :5;    
+
+  guint          zero_terminated :1;
+  guint          has_length      :1;
+  guint          reserved2       :6;
+
+  guint16        length;
+
+  SimpleTypeBlob type;
+} ArrayTypeBlob;
+
+typedef struct
+{
+  guint pointer    :1;
+  guint reserved   :2;
+  guint tag        :5;    
+
+  guint8         reserved2;
+  guint16        n_types;
+
+  SimpleTypeBlob type[];
+} ParamTypeBlob;
+
+typedef struct
+{
+  guint pointer    :1;
+  guint reserved   :2;
+  guint tag        :5;    
+
+  guint8     reserved2;
+  guint16    n_domains;
+
+  guint16    domains[];
+}  ErrorTypeBlob;
+
+typedef struct
+{
+  guint16 blob_type;  /* 10 */
+
+  guint   deprecated     : 1;
+  guint   reserved       :15;
+  
+  guint32 name;
+
+  guint32 get_quark;
+  guint16 error_codes;
+  guint16 reserved2;
+} ErrorDomainBlob;
+
+typedef struct
+{
+  guint   deprecated : 1;
+  guint   reserved   :31;
+  guint32 name;
+  guint32 value;
+} ValueBlob;
+
+typedef struct 
+{
+  guint32        name;
+
+  guint          readable : 1; 
+  guint          writable : 1;
+  guint          reserved : 6;
+  guint8         bits;
+
+  guint16        struct_offset;      
+
+  SimpleTypeBlob type;
+} FieldBlob;
+
+typedef struct
+{
+  guint16 blob_type;  
+  guint   deprecated   : 1; 
+  guint   unregistered :15;
+  guint32 name; 
+
+  guint32 gtype_name;
+  guint32 gtype_init;
+} RegisteredTypeBlob;
+
+typedef struct
+{
+  guint16   blob_type;
+
+  guint     deprecated   : 1;
+  guint     unregistered : 1;
+  guint     reserved     :14;
+
+  guint32   name;
+
+  guint32   gtype_name;
+  guint32   gtype_init;
+
+  guint16   n_fields;
+  guint16   n_methods;
+
+#if 0
+  /* variable-length parts of the blob */
+  FieldBlob    fields[];   
+  FunctionBlob methods[];
+#endif
+} StructBlob;
+
+typedef struct 
+{  
+  guint16      blob_type; 
+  guint        deprecated    : 1;
+  guint        unregistered  : 1;
+  guint        discriminated : 1;
+  guint        reserved      :13;
+  guint32      name;
+
+  guint32      gtype_name;
+  guint32      gtype_init;
+
+  guint16      n_fields;
+  guint16      n_functions;
+
+  gint32       discriminator_offset; 
+  SimpleTypeBlob discriminator_type;
+
+#if 0
+  FieldBlob    fields[];   
+  FunctionBlob functions[];  
+  ConstantBlob discriminator_values[]
+#endif
+} UnionBlob;
+
+typedef struct
+{
+  guint16   blob_type;
+
+  guint     deprecated   : 1; 
+  guint     unregistered : 1;
+  guint     reserved     :14;
+
+  guint32   name; 
+
+  guint32   gtype_name;
+  guint32   gtype_init;
+
+  guint16   n_values;
+  guint16   reserved2;
+
+  ValueBlob values[];    
+} EnumBlob;
+
+typedef struct
+{
+  guint32        name;
+
+  guint          deprecated     : 1;
+  guint          readable       : 1;
+  guint          writable       : 1;
+  guint          construct      : 1;
+  guint          construct_only : 1;
+  guint          reserved       :27;
+
+  SimpleTypeBlob type;
+
+} PropertyBlob;
+
+typedef struct
+{
+  guint   deprecated        : 1;
+  guint   run_first         : 1;
+  guint   run_last          : 1;
+  guint   run_cleanup       : 1;
+  guint   no_recurse        : 1;
+  guint   detailed          : 1;
+  guint   action            : 1;
+  guint   no_hooks          : 1;
+  guint   has_class_closure : 1;
+  guint   true_stops_emit   : 1;
+  guint   reserved          : 6;
+
+  guint16 class_closure;
+
+  guint32 name;
+
+  guint32 signature;
+} SignalBlob;
+
+typedef struct 
+{
+  guint32 name;
+
+  guint   must_chain_up           : 1;
+  guint   must_be_implemented     : 1;
+  guint   must_not_be_implemented : 1;
+  guint   class_closure           : 1;
+  guint   reserved                :12;
+  guint16 signal;
+
+  guint16 struct_offset;
+  guint16 reserved2;
+  guint32 signature;
+} VFuncBlob;
+
+typedef struct
+{
+  guint16   blob_type;  /* 7 */
+  guint     deprecated   : 1; 
+  guint     reserved     :15;
+  guint32   name; 
+
+  guint32   gtype_name;
+  guint32   gtype_init;
+
+  guint16   parent;
+
+  guint16   n_interfaces;
+  guint16   n_fields;
+  guint16   n_properties;
+  guint16   n_methods;
+  guint16   n_signals;
+  guint16   n_vfuncs;
+  guint16   n_constants;
+
+  guint16   interfaces[];
+ 
+#if 0
+  /* variable-length parts of the blob */
+  FieldBlob           fields[];
+  PropertyBlob        properties[];
+  FunctionBlob        methods[];
+  SignalBlob          signals[];
+  VFuncBlob           vfuncs[];
+  ConstantBlob        constants[];
+#endif
+} ObjectBlob;
+
+typedef struct 
+{
+  guint16 blob_type;  
+  guint   deprecated   : 1; 
+  guint   reserved     :15;
+  guint32 name; 
+
+  guint32 gtype_name;
+  guint32 gtype_init;
+
+  guint16 n_prerequisites;
+  guint16 n_properties;
+  guint16 n_methods;
+  guint16 n_signals;
+  guint16 n_vfuncs;
+  guint16 n_constants;  
+
+  guint16 prerequisites[];
+
+#if 0 
+  /* variable-length parts of the blob */
+  PropertyBlob        properties[];
+  FunctionBlob        methods[];
+  SignalBlob          signals[];
+  VFuncBlob           vfuncs[];
+  ConstantBlob        constants[];
+#endif
+} InterfaceBlob;
+
+
+typedef struct
+{
+  guint16        blob_type;
+  guint          deprecated   : 1; 
+  guint          reserved     :15;
+  guint32        name; 
+
+  SimpleTypeBlob type;
+
+  guint32        size;
+  guint32        offset;
+} ConstantBlob;
+
+typedef struct
+{ 
+  guint32 offset;
+  guint32 name;
+  guint32 value;
+} AnnotationBlob;
+
+
+
+DirEntry *g_metadata_get_dir_entry (const guchar *metadata,
+                                   guint16       index);
+
+void      g_metadata_check_sanity (void);
+
+#define   g_metadata_get_string(metadata,offset) ((const gchar*)&(metadata)[(offset)])
+
+
+typedef enum
+{
+  G_METADATA_ERROR_INVALID,
+  G_METADATA_ERROR_INVALID_HEADER,
+  G_METADATA_ERROR_INVALID_DIRECTORY,
+  G_METADATA_ERROR_INVALID_ENTRY,
+  G_METADATA_ERROR_INVALID_BLOB
+} GMetadataError;
+
+#define G_METADATA_ERROR (g_metadata_error_quark ())
+
+GQuark g_metadata_error_quark (void);
+
+gboolean g_metadata_validate (const guchar  *data,
+                             guint          len,
+                             GError       **error);
+
+
+G_END_DECLS
+
+#endif  /* __G_METADATA_H__ */
+

diff --git a/vapigen/packages/atk/atk.files b/vapigen/packages/atk/atk.files
new file mode 100644 (file)
index 0000000..f72e4d9
--- /dev/null
+++ b/vapigen/packages/atk/atk.files
@@ -0,0 +1 @@
+atk

diff --git a/vapigen/packages/atk/atk.gidl b/vapigen/packages/atk/atk.gidl
new file mode 100644 (file)
index 0000000..69463b8
--- /dev/null
+++ b/vapigen/packages/atk/atk.gidl
@@ -0,0 +1,3006 @@
+<?xml version="1.0"?>
+<api version="1.0">
+  <!--
+
+        This file was automatically generated.
+        Please DO NOT MODIFY THIS FILE, modify .metadata files instead.
+
+-->
+  <namespace name="Atk">
+    <enum get-type="atk_coord_type_get_type" name="AtkCoordType" type="enum" type-name="AtkCoordType">
+      <member name="ATK_XY_SCREEN" value=""/>
+      <member name="ATK_XY_WINDOW" value=""/>
+    </enum>
+    <enum get-type="atk_hyperlink_state_flags_get_type" name="AtkHyperlinkStateFlags" type="flags" type-name="AtkHyperlinkStateFlags">
+      <member name="ATK_HYPERLINK_IS_INLINE" value=""/>
+    </enum>
+    <enum get-type="atk_key_event_type_get_type" name="AtkKeyEventType" type="enum" type-name="AtkKeyEventType">
+      <member name="ATK_KEY_EVENT_PRESS" value=""/>
+      <member name="ATK_KEY_EVENT_RELEASE" value=""/>
+      <member name="ATK_KEY_EVENT_LAST_DEFINED" value=""/>
+    </enum>
+    <enum get-type="atk_layer_get_type" name="AtkLayer" type="enum" type-name="AtkLayer">
+      <member name="ATK_LAYER_INVALID" value=""/>
+      <member name="ATK_LAYER_BACKGROUND" value=""/>
+      <member name="ATK_LAYER_CANVAS" value=""/>
+      <member name="ATK_LAYER_WIDGET" value=""/>
+      <member name="ATK_LAYER_MDI" value=""/>
+      <member name="ATK_LAYER_POPUP" value=""/>
+      <member name="ATK_LAYER_OVERLAY" value=""/>
+      <member name="ATK_LAYER_WINDOW" value=""/>
+    </enum>
+    <enum get-type="atk_relation_type_get_type" name="AtkRelationType" type="enum" type-name="AtkRelationType">
+      <member name="ATK_RELATION_NULL" value="0"/>
+      <member name="ATK_RELATION_CONTROLLED_BY" value=""/>
+      <member name="ATK_RELATION_CONTROLLER_FOR" value=""/>
+      <member name="ATK_RELATION_LABEL_FOR" value=""/>
+      <member name="ATK_RELATION_LABELLED_BY" value=""/>
+      <member name="ATK_RELATION_MEMBER_OF" value=""/>
+      <member name="ATK_RELATION_NODE_CHILD_OF" value=""/>
+      <member name="ATK_RELATION_FLOWS_TO" value=""/>
+      <member name="ATK_RELATION_FLOWS_FROM" value=""/>
+      <member name="ATK_RELATION_SUBWINDOW_OF" value=""/>
+      <member name="ATK_RELATION_EMBEDS" value=""/>
+      <member name="ATK_RELATION_EMBEDDED_BY" value=""/>
+      <member name="ATK_RELATION_POPUP_FOR" value=""/>
+      <member name="ATK_RELATION_PARENT_WINDOW_OF" value=""/>
+      <member name="ATK_RELATION_DESCRIBED_BY" value=""/>
+      <member name="ATK_RELATION_DESCRIPTION_FOR" value=""/>
+      <member name="ATK_RELATION_LAST_DEFINED" value=""/>
+    </enum>
+    <enum get-type="atk_role_get_type" name="AtkRole" type="enum" type-name="AtkRole">
+      <member name="ATK_ROLE_INVALID" value="0"/>
+      <member name="ATK_ROLE_ACCEL_LABEL" value=""/>
+      <member name="ATK_ROLE_ALERT" value=""/>
+      <member name="ATK_ROLE_ANIMATION" value=""/>
+      <member name="ATK_ROLE_ARROW" value=""/>
+      <member name="ATK_ROLE_CALENDAR" value=""/>
+      <member name="ATK_ROLE_CANVAS" value=""/>
+      <member name="ATK_ROLE_CHECK_BOX" value=""/>
+      <member name="ATK_ROLE_CHECK_MENU_ITEM" value=""/>
+      <member name="ATK_ROLE_COLOR_CHOOSER" value=""/>
+      <member name="ATK_ROLE_COLUMN_HEADER" value=""/>
+      <member name="ATK_ROLE_COMBO_BOX" value=""/>
+      <member name="ATK_ROLE_DATE_EDITOR" value=""/>
+      <member name="ATK_ROLE_DESKTOP_ICON" value=""/>
+      <member name="ATK_ROLE_DESKTOP_FRAME" value=""/>
+      <member name="ATK_ROLE_DIAL" value=""/>
+      <member name="ATK_ROLE_DIALOG" value=""/>
+      <member name="ATK_ROLE_DIRECTORY_PANE" value=""/>
+      <member name="ATK_ROLE_DRAWING_AREA" value=""/>
+      <member name="ATK_ROLE_FILE_CHOOSER" value=""/>
+      <member name="ATK_ROLE_FILLER" value=""/>
+      <member name="ATK_ROLE_FONT_CHOOSER" value=""/>
+      <member name="ATK_ROLE_FRAME" value=""/>
+      <member name="ATK_ROLE_GLASS_PANE" value=""/>
+      <member name="ATK_ROLE_HTML_CONTAINER" value=""/>
+      <member name="ATK_ROLE_ICON" value=""/>
+      <member name="ATK_ROLE_IMAGE" value=""/>
+      <member name="ATK_ROLE_INTERNAL_FRAME" value=""/>
+      <member name="ATK_ROLE_LABEL" value=""/>
+      <member name="ATK_ROLE_LAYERED_PANE" value=""/>
+      <member name="ATK_ROLE_LIST" value=""/>
+      <member name="ATK_ROLE_LIST_ITEM" value=""/>
+      <member name="ATK_ROLE_MENU" value=""/>
+      <member name="ATK_ROLE_MENU_BAR" value=""/>
+      <member name="ATK_ROLE_MENU_ITEM" value=""/>
+      <member name="ATK_ROLE_OPTION_PANE" value=""/>
+      <member name="ATK_ROLE_PAGE_TAB" value=""/>
+      <member name="ATK_ROLE_PAGE_TAB_LIST" value=""/>
+      <member name="ATK_ROLE_PANEL" value=""/>
+      <member name="ATK_ROLE_PASSWORD_TEXT" value=""/>
+      <member name="ATK_ROLE_POPUP_MENU" value=""/>
+      <member name="ATK_ROLE_PROGRESS_BAR" value=""/>
+      <member name="ATK_ROLE_PUSH_BUTTON" value=""/>
+      <member name="ATK_ROLE_RADIO_BUTTON" value=""/>
+      <member name="ATK_ROLE_RADIO_MENU_ITEM" value=""/>
+      <member name="ATK_ROLE_ROOT_PANE" value=""/>
+      <member name="ATK_ROLE_ROW_HEADER" value=""/>
+      <member name="ATK_ROLE_SCROLL_BAR" value=""/>
+      <member name="ATK_ROLE_SCROLL_PANE" value=""/>
+      <member name="ATK_ROLE_SEPARATOR" value=""/>
+      <member name="ATK_ROLE_SLIDER" value=""/>
+      <member name="ATK_ROLE_SPLIT_PANE" value=""/>
+      <member name="ATK_ROLE_SPIN_BUTTON" value=""/>
+      <member name="ATK_ROLE_STATUSBAR" value=""/>
+      <member name="ATK_ROLE_TABLE" value=""/>
+      <member name="ATK_ROLE_TABLE_CELL" value=""/>
+      <member name="ATK_ROLE_TABLE_COLUMN_HEADER" value=""/>
+      <member name="ATK_ROLE_TABLE_ROW_HEADER" value=""/>
+      <member name="ATK_ROLE_TEAR_OFF_MENU_ITEM" value=""/>
+      <member name="ATK_ROLE_TERMINAL" value=""/>
+      <member name="ATK_ROLE_TEXT" value=""/>
+      <member name="ATK_ROLE_TOGGLE_BUTTON" value=""/>
+      <member name="ATK_ROLE_TOOL_BAR" value=""/>
+      <member name="ATK_ROLE_TOOL_TIP" value=""/>
+      <member name="ATK_ROLE_TREE" value=""/>
+      <member name="ATK_ROLE_TREE_TABLE" value=""/>
+      <member name="ATK_ROLE_UNKNOWN" value=""/>
+      <member name="ATK_ROLE_VIEWPORT" value=""/>
+      <member name="ATK_ROLE_WINDOW" value=""/>
+      <member name="ATK_ROLE_HEADER" value=""/>
+      <member name="ATK_ROLE_FOOTER" value=""/>
+      <member name="ATK_ROLE_PARAGRAPH" value=""/>
+      <member name="ATK_ROLE_RULER" value=""/>
+      <member name="ATK_ROLE_APPLICATION" value=""/>
+      <member name="ATK_ROLE_AUTOCOMPLETE" value=""/>
+      <member name="ATK_ROLE_EDITBAR" value=""/>
+      <member name="ATK_ROLE_EMBEDDED" value=""/>
+      <member name="ATK_ROLE_ENTRY" value=""/>
+      <member name="ATK_ROLE_CHART" value=""/>
+      <member name="ATK_ROLE_CAPTION" value=""/>
+      <member name="ATK_ROLE_DOCUMENT_FRAME" value=""/>
+      <member name="ATK_ROLE_HEADING" value=""/>
+      <member name="ATK_ROLE_PAGE" value=""/>
+      <member name="ATK_ROLE_SECTION" value=""/>
+      <member name="ATK_ROLE_REDUNDANT_OBJECT" value=""/>
+      <member name="ATK_ROLE_FORM" value=""/>
+      <member name="ATK_ROLE_LINK" value=""/>
+      <member name="ATK_ROLE_INPUT_METHOD_WINDOW" value=""/>
+      <member name="ATK_ROLE_LAST_DEFINED" value=""/>
+    </enum>
+    <enum get-type="atk_state_type_get_type" name="AtkStateType" type="enum" type-name="AtkStateType">
+      <member name="ATK_STATE_INVALID" value=""/>
+      <member name="ATK_STATE_ACTIVE" value=""/>
+      <member name="ATK_STATE_ARMED" value=""/>
+      <member name="ATK_STATE_BUSY" value=""/>
+      <member name="ATK_STATE_CHECKED" value=""/>
+      <member name="ATK_STATE_DEFUNCT" value=""/>
+      <member name="ATK_STATE_EDITABLE" value=""/>
+      <member name="ATK_STATE_ENABLED" value=""/>
+      <member name="ATK_STATE_EXPANDABLE" value=""/>
+      <member name="ATK_STATE_EXPANDED" value=""/>
+      <member name="ATK_STATE_FOCUSABLE" value=""/>
+      <member name="ATK_STATE_FOCUSED" value=""/>
+      <member name="ATK_STATE_HORIZONTAL" value=""/>
+      <member name="ATK_STATE_ICONIFIED" value=""/>
+      <member name="ATK_STATE_MODAL" value=""/>
+      <member name="ATK_STATE_MULTI_LINE" value=""/>
+      <member name="ATK_STATE_MULTISELECTABLE" value=""/>
+      <member name="ATK_STATE_OPAQUE" value=""/>
+      <member name="ATK_STATE_PRESSED" value=""/>
+      <member name="ATK_STATE_RESIZABLE" value=""/>
+      <member name="ATK_STATE_SELECTABLE" value=""/>
+      <member name="ATK_STATE_SELECTED" value=""/>
+      <member name="ATK_STATE_SENSITIVE" value=""/>
+      <member name="ATK_STATE_SHOWING" value=""/>
+      <member name="ATK_STATE_SINGLE_LINE" value=""/>
+      <member name="ATK_STATE_STALE" value=""/>
+      <member name="ATK_STATE_TRANSIENT" value=""/>
+      <member name="ATK_STATE_VERTICAL" value=""/>
+      <member name="ATK_STATE_VISIBLE" value=""/>
+      <member name="ATK_STATE_MANAGES_DESCENDANTS" value=""/>
+      <member name="ATK_STATE_INDETERMINATE" value=""/>
+      <member name="ATK_STATE_TRUNCATED" value=""/>
+      <member name="ATK_STATE_REQUIRED" value=""/>
+      <member name="ATK_STATE_INVALID_ENTRY" value=""/>
+      <member name="ATK_STATE_SUPPORTS_AUTOCOMPLETION" value=""/>
+      <member name="ATK_STATE_SELECTABLE_TEXT" value=""/>
+      <member name="ATK_STATE_DEFAULT" value=""/>
+      <member name="ATK_STATE_ANIMATED" value=""/>
+      <member name="ATK_STATE_VISITED" value=""/>
+      <member name="ATK_STATE_LAST_DEFINED" value=""/>
+    </enum>
+    <enum get-type="atk_text_attribute_get_type" name="AtkTextAttribute" type="enum" type-name="AtkTextAttribute">
+      <member name="ATK_TEXT_ATTR_INVALID" value="0"/>
+      <member name="ATK_TEXT_ATTR_LEFT_MARGIN" value=""/>
+      <member name="ATK_TEXT_ATTR_RIGHT_MARGIN" value=""/>
+      <member name="ATK_TEXT_ATTR_INDENT" value=""/>
+      <member name="ATK_TEXT_ATTR_INVISIBLE" value=""/>
+      <member name="ATK_TEXT_ATTR_EDITABLE" value=""/>
+      <member name="ATK_TEXT_ATTR_PIXELS_ABOVE_LINES" value=""/>
+      <member name="ATK_TEXT_ATTR_PIXELS_BELOW_LINES" value=""/>
+      <member name="ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP" value=""/>
+      <member name="ATK_TEXT_ATTR_BG_FULL_HEIGHT" value=""/>
+      <member name="ATK_TEXT_ATTR_RISE" value=""/>
+      <member name="ATK_TEXT_ATTR_UNDERLINE" value=""/>
+      <member name="ATK_TEXT_ATTR_STRIKETHROUGH" value=""/>
+      <member name="ATK_TEXT_ATTR_SIZE" value=""/>
+      <member name="ATK_TEXT_ATTR_SCALE" value=""/>
+      <member name="ATK_TEXT_ATTR_WEIGHT" value=""/>
+      <member name="ATK_TEXT_ATTR_LANGUAGE" value=""/>
+      <member name="ATK_TEXT_ATTR_FAMILY_NAME" value=""/>
+      <member name="ATK_TEXT_ATTR_BG_COLOR" value=""/>
+      <member name="ATK_TEXT_ATTR_FG_COLOR" value=""/>
+      <member name="ATK_TEXT_ATTR_BG_STIPPLE" value=""/>
+      <member name="ATK_TEXT_ATTR_FG_STIPPLE" value=""/>
+      <member name="ATK_TEXT_ATTR_WRAP_MODE" value=""/>
+      <member name="ATK_TEXT_ATTR_DIRECTION" value=""/>
+      <member name="ATK_TEXT_ATTR_JUSTIFICATION" value=""/>
+      <member name="ATK_TEXT_ATTR_STRETCH" value=""/>
+      <member name="ATK_TEXT_ATTR_VARIANT" value=""/>
+      <member name="ATK_TEXT_ATTR_STYLE" value=""/>
+      <member name="ATK_TEXT_ATTR_LAST_DEFINED" value=""/>
+    </enum>
+    <enum get-type="atk_text_boundary_get_type" name="AtkTextBoundary" type="enum" type-name="AtkTextBoundary">
+      <member name="ATK_TEXT_BOUNDARY_CHAR" value=""/>
+      <member name="ATK_TEXT_BOUNDARY_WORD_START" value=""/>
+      <member name="ATK_TEXT_BOUNDARY_WORD_END" value=""/>
+      <member name="ATK_TEXT_BOUNDARY_SENTENCE_START" value=""/>
+      <member name="ATK_TEXT_BOUNDARY_SENTENCE_END" value=""/>
+      <member name="ATK_TEXT_BOUNDARY_LINE_START" value=""/>
+      <member name="ATK_TEXT_BOUNDARY_LINE_END" value=""/>
+    </enum>
+    <enum get-type="atk_text_clip_type_get_type" name="AtkTextClipType" type="enum" type-name="AtkTextClipType">
+      <member name="ATK_TEXT_CLIP_NONE" value=""/>
+      <member name="ATK_TEXT_CLIP_MIN" value=""/>
+      <member name="ATK_TEXT_CLIP_MAX" value=""/>
+      <member name="ATK_TEXT_CLIP_BOTH" value=""/>
+    </enum>
+    <callback name="AtkEventListener" type-name="AtkEventListener">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="obj" type="AtkObject*"/>
+      </parameters>
+    </callback>
+    <callback name="AtkEventListenerInit" type-name="AtkEventListenerInit">
+      <return-type type="void"/>
+    </callback>
+    <callback name="AtkFocusHandler" type-name="AtkFocusHandler">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="arg1" type="AtkObject*"/>
+        <parameter name="arg2" type="gboolean"/>
+      </parameters>
+    </callback>
+    <callback name="AtkFunction" type-name="AtkFunction">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="AtkKeySnoopFunc" type-name="AtkKeySnoopFunc">
+      <return-type type="gint"/>
+      <parameters>
+        <parameter name="event" type="AtkKeyEventStruct*"/>
+        <parameter name="func_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="AtkPropertyChangeHandler" type-name="AtkPropertyChangeHandler">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="arg1" type="AtkObject*"/>
+        <parameter name="arg2" type="AtkPropertyValues*"/>
+      </parameters>
+    </callback>
+    <interface get-type="" name="AtkAction" type-name="AtkAction">
+      <vfunc name="do_action">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_actions">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_keybinding">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_description">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+          <parameter name="desc" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_localized_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="do_action" symbol="atk_action_do_action">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_description" symbol="atk_action_get_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_keybinding" symbol="atk_action_get_keybinding">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_localized_name" symbol="atk_action_get_localized_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_n_actions" symbol="atk_action_get_n_actions">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="atk_action_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_action_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_description" symbol="atk_action_set_description">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="AtkAction*"/>
+          <parameter name="i" type="gint"/>
+          <parameter name="desc" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkComponent" type-name="AtkComponent">
+      <signal name="bounds_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="bounds" type="AtkRectangle*"/>
+        </parameters>
+      </signal>
+      <vfunc name="add_focus_handler">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="handler" type="AtkFocusHandler"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="contains">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_accessible_at_point">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="grab_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_focus_handler">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="handler_id" type="guint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_extents">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_size">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_layer">
+        <return-type type="AtkLayer"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_mdi_zorder">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_alpha">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_focus_handler" symbol="atk_component_add_focus_handler">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="handler" type="AtkFocusHandler"/>
+        </parameters>
+      </method>
+      <method name="contains" symbol="atk_component_contains">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="get_alpha" symbol="atk_component_get_alpha">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </method>
+      <method name="get_extents" symbol="atk_component_get_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="get_layer" symbol="atk_component_get_layer">
+        <return-type type="AtkLayer"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </method>
+      <method name="get_mdi_zorder" symbol="atk_component_get_mdi_zorder">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </method>
+      <method name="get_position" symbol="atk_component_get_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="atk_component_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_component_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="grab_focus" symbol="atk_component_grab_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+        </parameters>
+      </method>
+      <method name="ref_accessible_at_point" symbol="atk_component_ref_accessible_at_point">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="remove_focus_handler" symbol="atk_component_remove_focus_handler">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="handler_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_extents" symbol="atk_component_set_extents">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="set_position" symbol="atk_component_set_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="set_size" symbol="atk_component_set_size">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="component" type="AtkComponent*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkDocument" type-name="AtkDocument">
+      <vfunc name="get_document_type">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_document">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_document_locale">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_document_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_document_attribute_value">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+          <parameter name="attribute_name" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_document_attribute">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+          <parameter name="attribute_name" type="const-gchar*"/>
+          <parameter name="attribute_value" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_attribute_value" symbol="atk_document_get_attribute_value">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+          <parameter name="attribute_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_attributes" symbol="atk_document_get_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </method>
+      <method name="get_document" symbol="atk_document_get_document">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </method>
+      <method name="get_document_type" symbol="atk_document_get_document_type">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </method>
+      <method name="get_locale" symbol="atk_document_get_locale">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_document_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_attribute_value" symbol="atk_document_set_attribute_value">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="document" type="AtkDocument*"/>
+          <parameter name="attribute_name" type="const-gchar*"/>
+          <parameter name="attribute_value" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkEditableText" type-name="AtkEditableText">
+      <vfunc name="set_run_attributes">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="attrib_set" type="AtkAttributeSet*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_text_contents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="insert_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="string" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="position" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="copy_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="cut_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="delete_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="paste_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="copy_text" symbol="atk_editable_text_copy_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="cut_text" symbol="atk_editable_text_cut_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="delete_text" symbol="atk_editable_text_delete_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_editable_text_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert_text" symbol="atk_editable_text_insert_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="string" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="position" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="paste_text" symbol="atk_editable_text_paste_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_run_attributes" symbol="atk_editable_text_set_run_attributes">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="attrib_set" type="AtkAttributeSet*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_text_contents" symbol="atk_editable_text_set_text_contents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkEditableText*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkHyperlinkImpl" type-name="AtkHyperlinkImpl">
+      <vfunc name="get_hyperlink">
+        <return-type type="AtkHyperlink"/>
+        <parameters>
+          <parameter name="impl" type="AtkHyperlinkImpl*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_hyperlink" symbol="atk_hyperlink_impl_get_hyperlink">
+        <return-type type="AtkHyperlink*"/>
+        <parameters>
+          <parameter name="obj" type="AtkHyperlinkImpl*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_hyperlink_impl_get_type">
+        <return-type type="GType"/>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkHypertext" type-name="AtkHypertext">
+      <signal name="link_selected" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+          <parameter name="link_index" type="gint"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_link">
+        <return-type type="AtkHyperlink*"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+          <parameter name="link_index" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_links">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_link_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+          <parameter name="char_index" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="get_link" symbol="atk_hypertext_get_link">
+        <return-type type="AtkHyperlink*"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+          <parameter name="link_index" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_link_index" symbol="atk_hypertext_get_link_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+          <parameter name="char_index" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_n_links" symbol="atk_hypertext_get_n_links">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="hypertext" type="AtkHypertext*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_hypertext_get_type">
+        <return-type type="GType"/>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkImage" type-name="AtkImage">
+      <vfunc name="get_image_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_image_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_image_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_image_description">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_image_locale">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_image_description" symbol="atk_image_get_image_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_image_locale" symbol="atk_image_get_image_locale">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_image_position" symbol="atk_image_get_image_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="get_image_size" symbol="atk_image_get_image_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_image_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_image_description" symbol="atk_image_set_image_description">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="image" type="AtkImage*"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkImplementor" type-name="AtkImplementor">
+      <vfunc name="ref_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="implementor" type="AtkImplementor*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_type" symbol="atk_implementor_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="ref_accessible" symbol="atk_implementor_ref_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="implementor" type="AtkImplementor*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkSelection" type-name="AtkSelection">
+      <signal name="selection_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </signal>
+      <vfunc name="add_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="clear_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_selection">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_selection_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_child_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="select_all_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_selection" symbol="atk_selection_add_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="clear_selection" symbol="atk_selection_clear_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_selection_count" symbol="atk_selection_get_selection_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_selection_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_child_selected" symbol="atk_selection_is_child_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="ref_selection" symbol="atk_selection_ref_selection">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="remove_selection" symbol="atk_selection_remove_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="select_all_selection" symbol="atk_selection_select_all_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="AtkSelection*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkStreamableContent" type-name="AtkStreamableContent">
+      <vfunc name="get_n_mime_types">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_mime_type">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_stream">
+        <return-type type="GIOChannel*"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_uri">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_mime_type" symbol="atk_streamable_content_get_mime_type">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_n_mime_types" symbol="atk_streamable_content_get_n_mime_types">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+        </parameters>
+      </method>
+      <method name="get_stream" symbol="atk_streamable_content_get_stream">
+        <return-type type="GIOChannel*"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_streamable_content_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uri" symbol="atk_streamable_content_get_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="streamable" type="AtkStreamableContent*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkTable" type-name="AtkTable">
+      <signal name="row_inserted" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="num_inserted" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="column_inserted" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="num_inserted" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="row_deleted" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="num_deleted" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="column_deleted" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="num_deleted" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="row_reordered" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </signal>
+      <signal name="column_reordered" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </signal>
+      <signal name="model_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </signal>
+      <vfunc name="ref_at">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_index_at">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_column_at_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_row_at_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_rows">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_column_extent_at">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_row_extent_at">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_caption">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_column_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_column_header">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_row_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_row_header">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_summary">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_caption">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="caption" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_column_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_column_header">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="header" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_row_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_row_header">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="header" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_summary">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_selected_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="selected" type="gint**"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_selected_rows">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="selected" type="gint**"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_column_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_row_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="add_row_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_row_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="add_column_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_column_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="add_column_selection" symbol="atk_table_add_column_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="add_row_selection" symbol="atk_table_add_row_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_caption" symbol="atk_table_get_caption">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_column_at_index" symbol="atk_table_get_column_at_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_column_description" symbol="atk_table_get_column_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_column_extent_at" symbol="atk_table_get_column_extent_at">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_column_header" symbol="atk_table_get_column_header">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_index_at" symbol="atk_table_get_index_at">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_n_columns" symbol="atk_table_get_n_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_n_rows" symbol="atk_table_get_n_rows">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_row_at_index" symbol="atk_table_get_row_at_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_row_description" symbol="atk_table_get_row_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_row_extent_at" symbol="atk_table_get_row_extent_at">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_row_header" symbol="atk_table_get_row_header">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_selected_columns" symbol="atk_table_get_selected_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="selected" type="gint**"/>
+        </parameters>
+      </method>
+      <method name="get_selected_rows" symbol="atk_table_get_selected_rows">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="selected" type="gint**"/>
+        </parameters>
+      </method>
+      <method name="get_summary" symbol="atk_table_get_summary">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_table_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_column_selected" symbol="atk_table_is_column_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="is_row_selected" symbol="atk_table_is_row_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </method>
+      <method name="is_selected" symbol="atk_table_is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="ref_at" symbol="atk_table_ref_at">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="remove_column_selection" symbol="atk_table_remove_column_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="remove_row_selection" symbol="atk_table_remove_row_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_caption" symbol="atk_table_set_caption">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="caption" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="set_column_description" symbol="atk_table_set_column_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_column_header" symbol="atk_table_set_column_header">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="header" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="set_row_description" symbol="atk_table_set_row_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_row_header" symbol="atk_table_set_row_header">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="row" type="gint"/>
+          <parameter name="header" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="set_summary" symbol="atk_table_set_summary">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="AtkTable*"/>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkText" type-name="AtkText">
+      <signal name="text_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="position" type="gint"/>
+          <parameter name="length" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="text_caret_moved" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="location" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="text_selection_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </signal>
+      <signal name="text_attributes_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_text_after_offset">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="boundary_type" type="AtkTextBoundary"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_text_at_offset">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="boundary_type" type="AtkTextBoundary"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_character_at_offset">
+        <return-type type="gunichar"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_text_before_offset">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="boundary_type" type="AtkTextBoundary"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_caret_offset">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_run_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_default_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_character_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+          <parameter name="coords" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_character_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_offset_at_point">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coords" type="AtkCoordType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_selections">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_selection">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="selection_num" type="gint"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="add_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="selection_num" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="selection_num" type="gint"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_caret_offset">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_range_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+          <parameter name="rect" type="AtkTextRectangle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_bounded_ranges">
+        <return-type type="AtkTextRange**"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="rect" type="AtkTextRectangle*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+          <parameter name="x_clip_type" type="AtkTextClipType"/>
+          <parameter name="y_clip_type" type="AtkTextClipType"/>
+        </parameters>
+      </vfunc>
+      <method name="add_selection" symbol="atk_text_add_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="attribute_for_name" symbol="atk_text_attribute_for_name">
+        <return-type type="AtkTextAttribute"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="attribute_get_name" symbol="atk_text_attribute_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="attr" type="AtkTextAttribute"/>
+        </parameters>
+      </method>
+      <method name="attribute_get_value" symbol="atk_text_attribute_get_value">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="attr" type="AtkTextAttribute"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="attribute_register" symbol="atk_text_attribute_register">
+        <return-type type="AtkTextAttribute"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="free_ranges" symbol="atk_text_free_ranges">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ranges" type="AtkTextRange**"/>
+        </parameters>
+      </method>
+      <method name="get_bounded_ranges" symbol="atk_text_get_bounded_ranges">
+        <return-type type="AtkTextRange**"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="rect" type="AtkTextRectangle*"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+          <parameter name="x_clip_type" type="AtkTextClipType"/>
+          <parameter name="y_clip_type" type="AtkTextClipType"/>
+        </parameters>
+      </method>
+      <method name="get_caret_offset" symbol="atk_text_get_caret_offset">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </method>
+      <method name="get_character_at_offset" symbol="atk_text_get_character_at_offset">
+        <return-type type="gunichar"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_character_count" symbol="atk_text_get_character_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </method>
+      <method name="get_character_extents" symbol="atk_text_get_character_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+          <parameter name="coords" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="get_default_attributes" symbol="atk_text_get_default_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </method>
+      <method name="get_n_selections" symbol="atk_text_get_n_selections">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+        </parameters>
+      </method>
+      <method name="get_offset_at_point" symbol="atk_text_get_offset_at_point">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="coords" type="AtkCoordType"/>
+        </parameters>
+      </method>
+      <method name="get_range_extents" symbol="atk_text_get_range_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+          <parameter name="coord_type" type="AtkCoordType"/>
+          <parameter name="rect" type="AtkTextRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_run_attributes" symbol="atk_text_get_run_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_selection" symbol="atk_text_get_selection">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="selection_num" type="gint"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="atk_text_get_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_text_after_offset" symbol="atk_text_get_text_after_offset">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="boundary_type" type="AtkTextBoundary"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_text_at_offset" symbol="atk_text_get_text_at_offset">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="boundary_type" type="AtkTextBoundary"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_text_before_offset" symbol="atk_text_get_text_before_offset">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="boundary_type" type="AtkTextBoundary"/>
+          <parameter name="start_offset" type="gint*"/>
+          <parameter name="end_offset" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_text_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="remove_selection" symbol="atk_text_remove_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="selection_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_caret_offset" symbol="atk_text_set_caret_offset">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_selection" symbol="atk_text_set_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text" type="AtkText*"/>
+          <parameter name="selection_num" type="gint"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="AtkValue" type-name="AtkValue">
+      <vfunc name="get_current_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_maximum_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_minimum_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_current_value">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="const-GValue*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_minimum_increment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_current_value" symbol="atk_value_get_current_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="get_maximum_value" symbol="atk_value_get_maximum_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="get_minimum_increment" symbol="atk_value_get_minimum_increment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="get_minimum_value" symbol="atk_value_get_minimum_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_value_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_current_value" symbol="atk_value_set_current_value">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="obj" type="AtkValue*"/>
+          <parameter name="value" type="const-GValue*"/>
+        </parameters>
+      </method>
+    </interface>
+    <object get-type="" name="AtkGObjectAccessible" parent="AtkObject" type-name="AtkGObjectAccessible">
+      <method name="for_object" symbol="atk_gobject_accessible_for_object">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="obj" type="GObject*"/>
+        </parameters>
+      </method>
+      <method name="get_object" symbol="atk_gobject_accessible_get_object">
+        <return-type type="GObject*"/>
+        <parameters>
+          <parameter name="obj" type="AtkGObjectAccessible*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_gobject_accessible_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="AtkHyperlink" parent="GObject" type-name="AtkHyperlink">
+      <property name="selected-link" readable="1" type="gboolean"/>
+      <property name="number-of-anchors" readable="1" type="gint"/>
+      <property name="end-index" readable="1" type="gint"/>
+      <property name="start-index" readable="1" type="gint"/>
+      <signal name="link_activated" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_object">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_end_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_start_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_anchors">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="link_state">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_selected_link">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </vfunc>
+      <implements>
+        <interface name="AtkAction"/>
+      </implements>
+      <method name="get_end_index" symbol="atk_hyperlink_get_end_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </method>
+      <method name="get_n_anchors" symbol="atk_hyperlink_get_n_anchors">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </method>
+      <method name="get_object" symbol="atk_hyperlink_get_object">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_start_index" symbol="atk_hyperlink_get_start_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_hyperlink_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uri" symbol="atk_hyperlink_get_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="is_inline" symbol="atk_hyperlink_is_inline">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </method>
+      <method name="is_selected_link" symbol="atk_hyperlink_is_selected_link">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </method>
+      <method name="is_valid" symbol="atk_hyperlink_is_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="link_" type="AtkHyperlink*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkNoOpObject" parent="AtkObject" type-name="AtkNoOpObject">
+      <implements>
+        <interface name="AtkComponent"/>
+        <interface name="AtkAction"/>
+        <interface name="AtkEditableText"/>
+        <interface name="AtkImage"/>
+        <interface name="AtkSelection"/>
+        <interface name="AtkTable"/>
+        <interface name="AtkText"/>
+        <interface name="AtkHypertext"/>
+        <interface name="AtkValue"/>
+      </implements>
+      <method name="get_type" symbol="atk_no_op_object_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="atk_no_op_object_new">
+        <parameters>
+          <parameter name="obj" type="GObject*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="AtkNoOpObjectFactory" parent="AtkObjectFactory" type-name="AtkNoOpObjectFactory">
+      <method name="get_type" symbol="atk_no_op_object_factory_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="atk_no_op_object_factory_new"/>
+    </object>
+    <object get-type="" name="AtkObject" parent="GObject" type-name="AtkObject">
+      <field name="description" type="gchar*"/>
+      <field name="name" type="gchar*"/>
+      <field name="accessible_parent" type="AtkObject*"/>
+      <field name="role" type="AtkRole"/>
+      <field name="relation_set" type="AtkRelationSet*"/>
+      <field name="layer" type="AtkLayer"/>
+      <property name="atk_object_name_property_name" readable="1" type="gchar*" writable="1"/>
+      <property name="atk_object_name_property_description" readable="1" type="gchar*" writable="1"/>
+      <property name="atk_object_name_property_parent" readable="1" type="AtkObject" writable="1"/>
+      <property name="atk_object_name_property_value" readable="1" type="gdouble" writable="1"/>
+      <property name="atk_object_name_property_role" readable="1" type="gint" writable="1"/>
+      <property name="atk_object_name_property_component_layer" readable="1" type="gint"/>
+      <property name="atk_object_name_property_component_mdi_zorder" readable="1" type="gint"/>
+      <property name="atk_object_name_property_table_caption" readable="1" type="gchar*" writable="1"/>
+      <property name="atk_object_name_property_table_column_header" readable="1" type="AtkObject" writable="1"/>
+      <property name="atk_object_name_property_table_column_description" readable="1" type="gchar*" writable="1"/>
+      <property name="atk_object_name_property_table_row_header" readable="1" type="AtkObject" writable="1"/>
+      <property name="atk_object_name_property_table_row_description" readable="1" type="gchar*" writable="1"/>
+      <property name="atk_object_name_property_table_summary" readable="1" type="AtkObject" writable="1"/>
+      <property name="atk_object_name_property_table_caption_object" readable="1" type="AtkObject" writable="1"/>
+      <property name="atk_object_name_property_hypertext_num_links" readable="1" type="gint"/>
+      <signal name="children_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="change_index" type="guint"/>
+          <parameter name="changed_child" type="gpointer"/>
+        </parameters>
+      </signal>
+      <signal name="focus_event" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="focus_in" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="property_change" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="values" type="AtkPropertyValues*"/>
+        </parameters>
+      </signal>
+      <signal name="state_change" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="state_set" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="visible_data_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </signal>
+      <signal name="active_descendant_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="child" type="gpointer*"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_parent">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_children">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_child">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_index_in_parent">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_relation_set">
+        <return-type type="AtkRelationSet*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_role">
+        <return-type type="AtkRole"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_layer">
+        <return-type type="AtkLayer"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_mdi_zorder">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_state_set">
+        <return-type type="AtkStateSet*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_parent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="parent" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_role">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="role" type="AtkRole"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="connect_property_change_handler">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="handler" type="AtkObjectAtkPropertyChangeHandler*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_property_change_handler">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="arg1" type="AtkObjectguinthandler_id"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="initialize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_relationship" symbol="atk_object_add_relationship">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="object" type="AtkObject*"/>
+          <parameter name="relationship" type="AtkRelationType"/>
+          <parameter name="target" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="connect_property_change_handler" symbol="atk_object_connect_property_change_handler">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="handler" type="AtkPropertyChangeHandler*"/>
+        </parameters>
+      </method>
+      <method name="get_attributes" symbol="atk_object_get_attributes">
+        <return-type type="AtkAttributeSet*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_description" symbol="atk_object_get_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_index_in_parent" symbol="atk_object_get_index_in_parent">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_layer" symbol="atk_object_get_layer">
+        <return-type type="AtkLayer"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_mdi_zorder" symbol="atk_object_get_mdi_zorder">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_n_accessible_children" symbol="atk_object_get_n_accessible_children">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="atk_object_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_parent" symbol="atk_object_get_parent">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_role" symbol="atk_object_get_role">
+        <return-type type="AtkRole"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_object_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="initialize" symbol="atk_object_initialize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="notify_state_change" symbol="atk_object_notify_state_change">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="state" type="AtkState"/>
+          <parameter name="value" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="ref_accessible_child" symbol="atk_object_ref_accessible_child">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="ref_relation_set" symbol="atk_object_ref_relation_set">
+        <return-type type="AtkRelationSet*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="ref_state_set" symbol="atk_object_ref_state_set">
+        <return-type type="AtkStateSet*"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="remove_property_change_handler" symbol="atk_object_remove_property_change_handler">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="handler_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="remove_relationship" symbol="atk_object_remove_relationship">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="object" type="AtkObject*"/>
+          <parameter name="relationship" type="AtkRelationType"/>
+          <parameter name="target" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="set_description" symbol="atk_object_set_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_name" symbol="atk_object_set_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_parent" symbol="atk_object_set_parent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="parent" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="set_role" symbol="atk_object_set_role">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="AtkObject*"/>
+          <parameter name="role" type="AtkRole"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkObjectFactory" parent="GObject" type-name="AtkObjectFactory">
+      <vfunc name="create_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="obj" type="GObject*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="invalidate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="factory" type="AtkObjectFactory*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_accessible_type">
+        <return-type type="GType"/>
+      </vfunc>
+      <method name="create_accessible" symbol="atk_object_factory_create_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="factory" type="AtkObjectFactory*"/>
+          <parameter name="obj" type="GObject*"/>
+        </parameters>
+      </method>
+      <method name="get_accessible_type" symbol="atk_object_factory_get_accessible_type">
+        <return-type type="GType"/>
+        <parameters>
+          <parameter name="factory" type="AtkObjectFactory*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_object_factory_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="invalidate" symbol="atk_object_factory_invalidate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="factory" type="AtkObjectFactory*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkRegistry" parent="GObject" type-name="AtkRegistry">
+      <field name="factory_type_registry" type="GHashTable*"/>
+      <field name="factory_singleton_cache" type="GHashTable*"/>
+      <method name="get_factory" symbol="atk_registry_get_factory">
+        <return-type type="AtkObjectFactory*"/>
+        <parameters>
+          <parameter name="registry" type="AtkRegistry*"/>
+          <parameter name="type" type="GType"/>
+        </parameters>
+      </method>
+      <method name="get_factory_type" symbol="atk_registry_get_factory_type">
+        <return-type type="GType"/>
+        <parameters>
+          <parameter name="registry" type="AtkRegistry*"/>
+          <parameter name="type" type="GType"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_registry_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_factory_type" symbol="atk_registry_set_factory_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="registry" type="AtkRegistry*"/>
+          <parameter name="type" type="GType"/>
+          <parameter name="factory_type" type="GType"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkRelation" parent="GObject" type-name="AtkRelation">
+      <field name="target" type="GPtrArray*"/>
+      <field name="relationship" type="AtkRelationType"/>
+      <property name="relation_type" readable="1" type="AtkRelationType" writable="1"/>
+      <property name="target" readable="1" type="value_array" writable="1"/>
+      <method name="add_target" symbol="atk_relation_add_target">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="relation" type="AtkRelation*"/>
+          <parameter name="target" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="get_relation_type" symbol="atk_relation_get_relation_type">
+        <return-type type="AtkRelationType"/>
+        <parameters>
+          <parameter name="relation" type="AtkRelation*"/>
+        </parameters>
+      </method>
+      <method name="get_target" symbol="atk_relation_get_target">
+        <return-type type="GPtrArray*"/>
+        <parameters>
+          <parameter name="relation" type="AtkRelation*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_relation_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="atk_relation_new">
+        <parameters>
+          <parameter name="targets" type="AtkObject**"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="relationship" type="AtkRelationType"/>
+        </parameters>
+      </constructor>
+      <method name="type_for_name" symbol="atk_relation_type_for_name">
+        <return-type type="AtkRelationType"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="type_get_name" symbol="atk_relation_type_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="type" type="AtkRelationType"/>
+        </parameters>
+      </method>
+      <method name="type_register" symbol="atk_relation_type_register">
+        <return-type type="AtkRelationType"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkRelationSet" parent="GObject" type-name="AtkRelationSet">
+      <field name="relations" type="GPtrArray*"/>
+      <method name="add" symbol="atk_relation_set_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+          <parameter name="relation" type="AtkRelation*"/>
+        </parameters>
+      </method>
+      <method name="add_relation_by_type" symbol="atk_relation_set_add_relation_by_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+          <parameter name="relationship" type="AtkRelationType"/>
+          <parameter name="target" type="AtkObject*"/>
+        </parameters>
+      </method>
+      <method name="contains" symbol="atk_relation_set_contains">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+          <parameter name="relationship" type="AtkRelationType"/>
+        </parameters>
+      </method>
+      <method name="get_n_relations" symbol="atk_relation_set_get_n_relations">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+        </parameters>
+      </method>
+      <method name="get_relation" symbol="atk_relation_set_get_relation">
+        <return-type type="AtkRelation*"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+          <parameter name="i" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_relation_by_type" symbol="atk_relation_set_get_relation_by_type">
+        <return-type type="AtkRelation*"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+          <parameter name="relationship" type="AtkRelationType"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_relation_set_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="atk_relation_set_new"/>
+      <method name="remove" symbol="atk_relation_set_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="AtkRelationSet*"/>
+          <parameter name="relation" type="AtkRelation*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkStateSet" parent="GObject" type-name="AtkStateSet">
+      <method name="add_state" symbol="atk_state_set_add_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="type" type="AtkStateType"/>
+        </parameters>
+      </method>
+      <method name="add_states" symbol="atk_state_set_add_states">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="types" type="AtkStateType*"/>
+          <parameter name="n_types" type="gint"/>
+        </parameters>
+      </method>
+      <method name="and_sets" symbol="atk_state_set_and_sets">
+        <return-type type="AtkStateSet*"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="compare_set" type="AtkStateSet*"/>
+        </parameters>
+      </method>
+      <method name="clear_states" symbol="atk_state_set_clear_states">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+        </parameters>
+      </method>
+      <method name="contains_state" symbol="atk_state_set_contains_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="type" type="AtkStateType"/>
+        </parameters>
+      </method>
+      <method name="contains_states" symbol="atk_state_set_contains_states">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="types" type="AtkStateType*"/>
+          <parameter name="n_types" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="atk_state_set_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_empty" symbol="atk_state_set_is_empty">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="atk_state_set_new"/>
+      <method name="or_sets" symbol="atk_state_set_or_sets">
+        <return-type type="AtkStateSet*"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="compare_set" type="AtkStateSet*"/>
+        </parameters>
+      </method>
+      <method name="remove_state" symbol="atk_state_set_remove_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="type" type="AtkStateType"/>
+        </parameters>
+      </method>
+      <method name="xor_sets" symbol="atk_state_set_xor_sets">
+        <return-type type="AtkStateSet*"/>
+        <parameters>
+          <parameter name="set" type="AtkStateSet*"/>
+          <parameter name="compare_set" type="AtkStateSet*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="AtkUtil" parent="GObject" type-name="AtkUtil">
+      <vfunc name="add_global_event_listener">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="listener" type="GSignalEmissionHook"/>
+          <parameter name="event_type" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_global_event_listener">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="listener_id" type="guint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="add_key_event_listener">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="listener" type="AtkKeySnoopFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_key_event_listener">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="listener_id" type="guint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_root">
+        <return-type type="AtkObject*"/>
+      </vfunc>
+      <vfunc name="get_toolkit_name">
+        <return-type type="const-gchar*"/>
+      </vfunc>
+      <vfunc name="get_toolkit_version">
+        <return-type type="const-gchar*"/>
+      </vfunc>
+      <method name="get_type" symbol="atk_util_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <struct get-type="" name="AtkAttribute" type-name="AtkAttribute">
+      <field name="name" readable="1" type="gchar*" writable="1"/>
+      <field name="value" readable="1" type="gchar*" writable="1"/>
+      <method name="set_free" symbol="atk_attribute_set_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="attrib_set" type="AtkAttributeSet*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="AtkKeyEventStruct" type-name="AtkKeyEventStruct">
+      <field name="type" readable="1" type="gint" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+      <field name="keyval" readable="1" type="guint" writable="1"/>
+      <field name="length" readable="1" type="gint" writable="1"/>
+      <field name="string" readable="1" type="gchar*" writable="1"/>
+      <field name="keycode" readable="1" type="guint16" writable="1"/>
+      <field name="timestamp" readable="1" type="guint32" writable="1"/>
+    </struct>
+    <struct get-type="" name="AtkPropertyValues" type-name="AtkPropertyValues">
+      <field name="property_name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="old_value" readable="1" type="GValue" writable="1"/>
+      <field name="new_value" readable="1" type="GValue" writable="1"/>
+    </struct>
+    <boxed get-type="" name="AtkRectangle" type-name="AtkRectangle">
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+      <method name="get_type" symbol="atk_rectangle_get_type">
+        <return-type type="GType"/>
+      </method>
+    </boxed>
+    <struct get-type="" name="AtkTextRange" type-name="AtkTextRange">
+      <field name="bounds" readable="1" type="AtkTextRectangle" writable="1"/>
+      <field name="start_offset" readable="1" type="gint" writable="1"/>
+      <field name="end_offset" readable="1" type="gint" writable="1"/>
+      <field name="content" readable="1" type="gchar*" writable="1"/>
+    </struct>
+    <struct get-type="" name="AtkTextRectangle" type-name="AtkTextRectangle">
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct cname="AtkGlobal" name="Global">
+      <method name="_add_focus_tracker" symbol="atk_add_focus_tracker">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="focus_tracker" type="AtkEventListener"/>
+        </parameters>
+      </method>
+      <method name="_add_global_event_listener" symbol="atk_add_global_event_listener">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="listener" type="GSignalEmissionHook"/>
+          <parameter name="event_type" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="_add_key_event_listener" symbol="atk_add_key_event_listener">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="listener" type="AtkKeySnoopFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="_get_default_registry" symbol="atk_get_default_registry">
+        <return-type type="AtkRegistry*"/>
+      </method>
+      <method name="_get_focus_object" symbol="atk_get_focus_object">
+        <return-type type="AtkObject*"/>
+      </method>
+      <method name="_get_root" symbol="atk_get_root">
+        <return-type type="AtkObject*"/>
+      </method>
+      <method name="_get_toolkit_name" symbol="atk_get_toolkit_name">
+        <return-type type="const-gchar*"/>
+      </method>
+      <method name="_get_toolkit_version" symbol="atk_get_toolkit_version">
+        <return-type type="const-gchar*"/>
+      </method>
+      <method name="_remove_focus_tracker" symbol="atk_remove_focus_tracker">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tracker_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="_remove_global_event_listener" symbol="atk_remove_global_event_listener">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="listener_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="_remove_key_event_listener" symbol="atk_remove_key_event_listener">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="listener_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="_role_for_name" symbol="atk_role_for_name">
+        <return-type type="AtkRole"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="_role_get_localized_name" symbol="atk_role_get_localized_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="role" type="AtkRole"/>
+        </parameters>
+      </method>
+      <method name="_role_get_name" symbol="atk_role_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="role" type="AtkRole"/>
+        </parameters>
+      </method>
+      <method name="_role_register" symbol="atk_role_register">
+        <return-type type="AtkRole"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="AtkFocus">
+      <method name="tracker_init" symbol="atk_focus_tracker_init">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="init" type="AtkEventListenerInit"/>
+        </parameters>
+      </method>
+      <method name="tracker_notify" symbol="atk_focus_tracker_notify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="AtkObject*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="AtkState">
+      <method name="type_for_name" symbol="atk_state_type_for_name">
+        <return-type type="AtkStateType"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="type_get_name" symbol="atk_state_type_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="type" type="AtkStateType"/>
+        </parameters>
+      </method>
+      <method name="type_register" symbol="atk_state_type_register">
+        <return-type type="AtkStateType"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </struct>
+  </namespace>
+</api>

diff --git a/vapigen/packages/atk/atk.namespace b/vapigen/packages/atk/atk.namespace
new file mode 100644 (file)
index 0000000..83fd424
--- /dev/null
+++ b/vapigen/packages/atk/atk.namespace
@@ -0,0 +1 @@
+Atk

diff --git a/vapigen/packages/gdk-2.0/gdk-2.0.excludes b/vapigen/packages/gdk-2.0/gdk-2.0.excludes
new file mode 100644 (file)
index 0000000..89f974e
--- /dev/null
+++ b/vapigen/packages/gdk-2.0/gdk-2.0.excludes
@@ -0,0 +1,4 @@
+gdkalias.h
+keyname-table.h
+gdk-pixbuf-alias.h
+xpm-color-table.h

diff --git a/vapigen/packages/gdk-2.0/gdk-2.0.files b/vapigen/packages/gdk-2.0/gdk-2.0.files
new file mode 100644 (file)
index 0000000..0180eb1
--- /dev/null
+++ b/vapigen/packages/gdk-2.0/gdk-2.0.files
@@ -0,0 +1,2 @@
+gdk
+gdk-pixbuf

diff --git a/vapigen/packages/gdk-2.0/gdk-2.0.gidl b/vapigen/packages/gdk-2.0/gdk-2.0.gidl
new file mode 100644 (file)
index 0000000..aa6faba
--- /dev/null
+++ b/vapigen/packages/gdk-2.0/gdk-2.0.gidl
@@ -0,0 +1,6098 @@
+<?xml version="1.0"?>
+<api version="1.0">
+  <!--
+
+        This file was automatically generated.
+        Please DO NOT MODIFY THIS FILE, modify .metadata files instead.
+
+-->
+  <namespace name="Gdk">
+    <enum get-type="gdk_axis_use_get_type" name="GdkAxisUse" type="enum" type-name="GdkAxisUse">
+      <member name="GDK_AXIS_IGNORE" value=""/>
+      <member name="GDK_AXIS_X" value=""/>
+      <member name="GDK_AXIS_Y" value=""/>
+      <member name="GDK_AXIS_PRESSURE" value=""/>
+      <member name="GDK_AXIS_XTILT" value=""/>
+      <member name="GDK_AXIS_YTILT" value=""/>
+      <member name="GDK_AXIS_WHEEL" value=""/>
+      <member name="GDK_AXIS_LAST" value=""/>
+    </enum>
+    <enum get-type="gdk_byte_order_get_type" name="GdkByteOrder" type="enum" type-name="GdkByteOrder">
+      <member name="GDK_LSB_FIRST" value=""/>
+      <member name="GDK_MSB_FIRST" value=""/>
+    </enum>
+    <enum get-type="gdk_cap_style_get_type" name="GdkCapStyle" type="enum" type-name="GdkCapStyle">
+      <member name="GDK_CAP_NOT_LAST" value=""/>
+      <member name="GDK_CAP_BUTT" value=""/>
+      <member name="GDK_CAP_ROUND" value=""/>
+      <member name="GDK_CAP_PROJECTING" value=""/>
+    </enum>
+    <enum get-type="gdk_colorspace_get_type" name="GdkColorspace" type="enum" type-name="GdkColorspace">
+      <member name="GDK_COLORSPACE_RGB" value=""/>
+    </enum>
+    <enum get-type="gdk_crossing_mode_get_type" name="GdkCrossingMode" type="enum" type-name="GdkCrossingMode">
+      <member name="GDK_CROSSING_NORMAL" value=""/>
+      <member name="GDK_CROSSING_GRAB" value=""/>
+      <member name="GDK_CROSSING_UNGRAB" value=""/>
+    </enum>
+    <enum get-type="gdk_cursor_type_get_type" name="GdkCursorType" type="enum" type-name="GdkCursorType">
+      <member name="GDK_X_CURSOR" value="0"/>
+      <member name="GDK_ARROW" value="2"/>
+      <member name="GDK_BASED_ARROW_DOWN" value="4"/>
+      <member name="GDK_BASED_ARROW_UP" value="6"/>
+      <member name="GDK_BOAT" value="8"/>
+      <member name="GDK_BOGOSITY" value="10"/>
+      <member name="GDK_BOTTOM_LEFT_CORNER" value="12"/>
+      <member name="GDK_BOTTOM_RIGHT_CORNER" value="14"/>
+      <member name="GDK_BOTTOM_SIDE" value="16"/>
+      <member name="GDK_BOTTOM_TEE" value="18"/>
+      <member name="GDK_BOX_SPIRAL" value="20"/>
+      <member name="GDK_CENTER_PTR" value="22"/>
+      <member name="GDK_CIRCLE" value="24"/>
+      <member name="GDK_CLOCK" value="26"/>
+      <member name="GDK_COFFEE_MUG" value="28"/>
+      <member name="GDK_CROSS" value="30"/>
+      <member name="GDK_CROSS_REVERSE" value="32"/>
+      <member name="GDK_CROSSHAIR" value="34"/>
+      <member name="GDK_DIAMOND_CROSS" value="36"/>
+      <member name="GDK_DOT" value="38"/>
+      <member name="GDK_DOTBOX" value="40"/>
+      <member name="GDK_DOUBLE_ARROW" value="42"/>
+      <member name="GDK_DRAFT_LARGE" value="44"/>
+      <member name="GDK_DRAFT_SMALL" value="46"/>
+      <member name="GDK_DRAPED_BOX" value="48"/>
+      <member name="GDK_EXCHANGE" value="50"/>
+      <member name="GDK_FLEUR" value="52"/>
+      <member name="GDK_GOBBLER" value="54"/>
+      <member name="GDK_GUMBY" value="56"/>
+      <member name="GDK_HAND1" value="58"/>
+      <member name="GDK_HAND2" value="60"/>
+      <member name="GDK_HEART" value="62"/>
+      <member name="GDK_ICON" value="64"/>
+      <member name="GDK_IRON_CROSS" value="66"/>
+      <member name="GDK_LEFT_PTR" value="68"/>
+      <member name="GDK_LEFT_SIDE" value="70"/>
+      <member name="GDK_LEFT_TEE" value="72"/>
+      <member name="GDK_LEFTBUTTON" value="74"/>
+      <member name="GDK_LL_ANGLE" value="76"/>
+      <member name="GDK_LR_ANGLE" value="78"/>
+      <member name="GDK_MAN" value="80"/>
+      <member name="GDK_MIDDLEBUTTON" value="82"/>
+      <member name="GDK_MOUSE" value="84"/>
+      <member name="GDK_PENCIL" value="86"/>
+      <member name="GDK_PIRATE" value="88"/>
+      <member name="GDK_PLUS" value="90"/>
+      <member name="GDK_QUESTION_ARROW" value="92"/>
+      <member name="GDK_RIGHT_PTR" value="94"/>
+      <member name="GDK_RIGHT_SIDE" value="96"/>
+      <member name="GDK_RIGHT_TEE" value="98"/>
+      <member name="GDK_RIGHTBUTTON" value="100"/>
+      <member name="GDK_RTL_LOGO" value="102"/>
+      <member name="GDK_SAILBOAT" value="104"/>
+      <member name="GDK_SB_DOWN_ARROW" value="106"/>
+      <member name="GDK_SB_H_DOUBLE_ARROW" value="108"/>
+      <member name="GDK_SB_LEFT_ARROW" value="110"/>
+      <member name="GDK_SB_RIGHT_ARROW" value="112"/>
+      <member name="GDK_SB_UP_ARROW" value="114"/>
+      <member name="GDK_SB_V_DOUBLE_ARROW" value="116"/>
+      <member name="GDK_SHUTTLE" value="118"/>
+      <member name="GDK_SIZING" value="120"/>
+      <member name="GDK_SPIDER" value="122"/>
+      <member name="GDK_SPRAYCAN" value="124"/>
+      <member name="GDK_STAR" value="126"/>
+      <member name="GDK_TARGET" value="128"/>
+      <member name="GDK_TCROSS" value="130"/>
+      <member name="GDK_TOP_LEFT_ARROW" value="132"/>
+      <member name="GDK_TOP_LEFT_CORNER" value="134"/>
+      <member name="GDK_TOP_RIGHT_CORNER" value="136"/>
+      <member name="GDK_TOP_SIDE" value="138"/>
+      <member name="GDK_TOP_TEE" value="140"/>
+      <member name="GDK_TREK" value="142"/>
+      <member name="GDK_UL_ANGLE" value="144"/>
+      <member name="GDK_UMBRELLA" value="146"/>
+      <member name="GDK_UR_ANGLE" value="148"/>
+      <member name="GDK_WATCH" value="150"/>
+      <member name="GDK_XTERM" value="152"/>
+      <member name="GDK_LAST_CURSOR" value=""/>
+      <member name="GDK_CURSOR_IS_PIXMAP" value="-1"/>
+    </enum>
+    <enum get-type="gdk_drag_action_get_type" name="GdkDragAction" type="flags" type-name="GdkDragAction">
+      <member name="GDK_ACTION_DEFAULT" value=""/>
+      <member name="GDK_ACTION_COPY" value=""/>
+      <member name="GDK_ACTION_MOVE" value=""/>
+      <member name="GDK_ACTION_LINK" value=""/>
+      <member name="GDK_ACTION_PRIVATE" value=""/>
+      <member name="GDK_ACTION_ASK" value=""/>
+    </enum>
+    <enum get-type="gdk_drag_protocol_get_type" name="GdkDragProtocol" type="enum" type-name="GdkDragProtocol">
+      <member name="GDK_DRAG_PROTO_MOTIF" value=""/>
+      <member name="GDK_DRAG_PROTO_XDND" value=""/>
+      <member name="GDK_DRAG_PROTO_ROOTWIN" value=""/>
+      <member name="GDK_DRAG_PROTO_NONE" value=""/>
+      <member name="GDK_DRAG_PROTO_WIN32_DROPFILES" value=""/>
+      <member name="GDK_DRAG_PROTO_OLE2" value=""/>
+      <member name="GDK_DRAG_PROTO_LOCAL" value=""/>
+    </enum>
+    <enum get-type="gdk_event_mask_get_type" name="GdkEventMask" type="flags" type-name="GdkEventMask">
+      <member name="GDK_EXPOSURE_MASK" value=""/>
+      <member name="GDK_POINTER_MOTION_MASK" value=""/>
+      <member name="GDK_POINTER_MOTION_HINT_MASK" value=""/>
+      <member name="GDK_BUTTON_MOTION_MASK" value=""/>
+      <member name="GDK_BUTTON1_MOTION_MASK" value=""/>
+      <member name="GDK_BUTTON2_MOTION_MASK" value=""/>
+      <member name="GDK_BUTTON3_MOTION_MASK" value=""/>
+      <member name="GDK_BUTTON_PRESS_MASK" value=""/>
+      <member name="GDK_BUTTON_RELEASE_MASK" value=""/>
+      <member name="GDK_KEY_PRESS_MASK" value=""/>
+      <member name="GDK_KEY_RELEASE_MASK" value=""/>
+      <member name="GDK_ENTER_NOTIFY_MASK" value=""/>
+      <member name="GDK_LEAVE_NOTIFY_MASK" value=""/>
+      <member name="GDK_FOCUS_CHANGE_MASK" value=""/>
+      <member name="GDK_STRUCTURE_MASK" value=""/>
+      <member name="GDK_PROPERTY_CHANGE_MASK" value=""/>
+      <member name="GDK_VISIBILITY_NOTIFY_MASK" value=""/>
+      <member name="GDK_PROXIMITY_IN_MASK" value=""/>
+      <member name="GDK_PROXIMITY_OUT_MASK" value=""/>
+      <member name="GDK_SUBSTRUCTURE_MASK" value=""/>
+      <member name="GDK_SCROLL_MASK" value=""/>
+      <member name="GDK_ALL_EVENTS_MASK" value="0x3FFFFE"/>
+    </enum>
+    <enum get-type="gdk_event_type_get_type" name="GdkEventType" type="enum" type-name="GdkEventType">
+      <member name="GDK_NOTHING" value="-1"/>
+      <member name="GDK_DELETE" value="0"/>
+      <member name="GDK_DESTROY" value="1"/>
+      <member name="GDK_EXPOSE" value="2"/>
+      <member name="GDK_MOTION_NOTIFY" value="3"/>
+      <member name="GDK_BUTTON_PRESS" value="4"/>
+      <member name="GDK_2BUTTON_PRESS" value="5"/>
+      <member name="GDK_3BUTTON_PRESS" value="6"/>
+      <member name="GDK_BUTTON_RELEASE" value="7"/>
+      <member name="GDK_KEY_PRESS" value="8"/>
+      <member name="GDK_KEY_RELEASE" value="9"/>
+      <member name="GDK_ENTER_NOTIFY" value="10"/>
+      <member name="GDK_LEAVE_NOTIFY" value="11"/>
+      <member name="GDK_FOCUS_CHANGE" value="12"/>
+      <member name="GDK_CONFIGURE" value="13"/>
+      <member name="GDK_MAP" value="14"/>
+      <member name="GDK_UNMAP" value="15"/>
+      <member name="GDK_PROPERTY_NOTIFY" value="16"/>
+      <member name="GDK_SELECTION_CLEAR" value="17"/>
+      <member name="GDK_SELECTION_REQUEST" value="18"/>
+      <member name="GDK_SELECTION_NOTIFY" value="19"/>
+      <member name="GDK_PROXIMITY_IN" value="20"/>
+      <member name="GDK_PROXIMITY_OUT" value="21"/>
+      <member name="GDK_DRAG_ENTER" value="22"/>
+      <member name="GDK_DRAG_LEAVE" value="23"/>
+      <member name="GDK_DRAG_MOTION" value="24"/>
+      <member name="GDK_DRAG_STATUS" value="25"/>
+      <member name="GDK_DROP_START" value="26"/>
+      <member name="GDK_DROP_FINISHED" value="27"/>
+      <member name="GDK_CLIENT_EVENT" value="28"/>
+      <member name="GDK_VISIBILITY_NOTIFY" value="29"/>
+      <member name="GDK_NO_EXPOSE" value="30"/>
+      <member name="GDK_SCROLL" value="31"/>
+      <member name="GDK_WINDOW_STATE" value="32"/>
+      <member name="GDK_SETTING" value="33"/>
+      <member name="GDK_OWNER_CHANGE" value="34"/>
+      <member name="GDK_GRAB_BROKEN" value="35"/>
+    </enum>
+    <enum get-type="gdk_extension_mode_get_type" name="GdkExtensionMode" type="enum" type-name="GdkExtensionMode">
+      <member name="GDK_EXTENSION_EVENTS_NONE" value=""/>
+      <member name="GDK_EXTENSION_EVENTS_ALL" value=""/>
+      <member name="GDK_EXTENSION_EVENTS_CURSOR" value=""/>
+    </enum>
+    <enum get-type="gdk_fill_get_type" name="GdkFill" type="enum" type-name="GdkFill">
+      <member name="GDK_SOLID" value=""/>
+      <member name="GDK_TILED" value=""/>
+      <member name="GDK_STIPPLED" value=""/>
+      <member name="GDK_OPAQUE_STIPPLED" value=""/>
+    </enum>
+    <enum get-type="gdk_fill_rule_get_type" name="GdkFillRule" type="enum" type-name="GdkFillRule">
+      <member name="GDK_EVEN_ODD_RULE" value=""/>
+      <member name="GDK_WINDING_RULE" value=""/>
+    </enum>
+    <enum get-type="gdk_filter_return_get_type" name="GdkFilterReturn" type="enum" type-name="GdkFilterReturn">
+      <member name="GDK_FILTER_CONTINUE" value=""/>
+      <member name="GDK_FILTER_TRANSLATE" value=""/>
+      <member name="GDK_FILTER_REMOVE" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gdk_font_type_get_type" name="GdkFontType" type="enum" type-name="GdkFontType">
+      <member name="GDK_FONT_FONT" value=""/>
+      <member name="GDK_FONT_FONTSET" value=""/>
+    </enum>
+    <enum get-type="gdk_function_get_type" name="GdkFunction" type="enum" type-name="GdkFunction">
+      <member name="GDK_COPY" value=""/>
+      <member name="GDK_INVERT" value=""/>
+      <member name="GDK_XOR" value=""/>
+      <member name="GDK_CLEAR" value=""/>
+      <member name="GDK_AND" value=""/>
+      <member name="GDK_AND_REVERSE" value=""/>
+      <member name="GDK_AND_INVERT" value=""/>
+      <member name="GDK_NOOP" value=""/>
+      <member name="GDK_OR" value=""/>
+      <member name="GDK_EQUIV" value=""/>
+      <member name="GDK_OR_REVERSE" value=""/>
+      <member name="GDK_COPY_INVERT" value=""/>
+      <member name="GDK_OR_INVERT" value=""/>
+      <member name="GDK_NAND" value=""/>
+      <member name="GDK_NOR" value=""/>
+      <member name="GDK_SET" value=""/>
+    </enum>
+    <enum name="GdkGCValuesMask" type="flags" type-name="GdkGCValuesMask">
+      <member name="GDK_GC_FOREGROUND" value=""/>
+      <member name="GDK_GC_BACKGROUND" value=""/>
+      <member name="GDK_GC_FONT" value=""/>
+      <member name="GDK_GC_FUNCTION" value=""/>
+      <member name="GDK_GC_FILL" value=""/>
+      <member name="GDK_GC_TILE" value=""/>
+      <member name="GDK_GC_STIPPLE" value=""/>
+      <member name="GDK_GC_CLIP_MASK" value=""/>
+      <member name="GDK_GC_SUBWINDOW" value=""/>
+      <member name="GDK_GC_TS_X_ORIGIN" value=""/>
+      <member name="GDK_GC_TS_Y_ORIGIN" value=""/>
+      <member name="GDK_GC_CLIP_X_ORIGIN" value=""/>
+      <member name="GDK_GC_CLIP_Y_ORIGIN" value=""/>
+      <member name="GDK_GC_EXPOSURES" value=""/>
+      <member name="GDK_GC_LINE_WIDTH" value=""/>
+      <member name="GDK_GC_LINE_STYLE" value=""/>
+      <member name="GDK_GC_CAP_STYLE" value=""/>
+      <member name="GDK_GC_JOIN_STYLE" value=""/>
+    </enum>
+    <enum get-type="gdk_grab_status_get_type" name="GdkGrabStatus" type="enum" type-name="GdkGrabStatus">
+      <member name="GDK_GRAB_SUCCESS" value="0"/>
+      <member name="GDK_GRAB_ALREADY_GRABBED" value="1"/>
+      <member name="GDK_GRAB_INVALID_TIME" value="2"/>
+      <member name="GDK_GRAB_NOT_VIEWABLE" value="3"/>
+      <member name="GDK_GRAB_FROZEN" value="4"/>
+    </enum>
+    <enum get-type="gdk_gravity_get_type" name="GdkGravity" type="enum" type-name="GdkGravity">
+      <member name="GDK_GRAVITY_NORTH_WEST" value="1"/>
+      <member name="GDK_GRAVITY_NORTH" value=""/>
+      <member name="GDK_GRAVITY_NORTH_EAST" value=""/>
+      <member name="GDK_GRAVITY_WEST" value=""/>
+      <member name="GDK_GRAVITY_CENTER" value=""/>
+      <member name="GDK_GRAVITY_EAST" value=""/>
+      <member name="GDK_GRAVITY_SOUTH_WEST" value=""/>
+      <member name="GDK_GRAVITY_SOUTH" value=""/>
+      <member name="GDK_GRAVITY_SOUTH_EAST" value=""/>
+      <member name="GDK_GRAVITY_STATIC" value=""/>
+    </enum>
+    <enum get-type="gdk_image_type_get_type" name="GdkImageType" type="enum" type-name="GdkImageType">
+      <member name="GDK_IMAGE_NORMAL" value=""/>
+      <member name="GDK_IMAGE_SHARED" value=""/>
+      <member name="GDK_IMAGE_FASTEST" value=""/>
+    </enum>
+    <enum get-type="gdk_input_condition_get_type" name="GdkInputCondition" type="flags" type-name="GdkInputCondition">
+      <member name="GDK_INPUT_READ" value=""/>
+      <member name="GDK_INPUT_WRITE" value=""/>
+      <member name="GDK_INPUT_EXCEPTION" value=""/>
+    </enum>
+    <enum get-type="gdk_input_mode_get_type" name="GdkInputMode" type="enum" type-name="GdkInputMode">
+      <member name="GDK_MODE_DISABLED" value=""/>
+      <member name="GDK_MODE_SCREEN" value=""/>
+      <member name="GDK_MODE_WINDOW" value=""/>
+    </enum>
+    <enum get-type="gdk_input_source_get_type" name="GdkInputSource" type="enum" type-name="GdkInputSource">
+      <member name="GDK_SOURCE_MOUSE" value=""/>
+      <member name="GDK_SOURCE_PEN" value=""/>
+      <member name="GDK_SOURCE_ERASER" value=""/>
+      <member name="GDK_SOURCE_CURSOR" value=""/>
+    </enum>
+    <enum get-type="gdk_interp_type_get_type" name="GdkInterpType" type="enum" type-name="GdkInterpType">
+      <member name="GDK_INTERP_NEAREST" value=""/>
+      <member name="GDK_INTERP_TILES" value=""/>
+      <member name="GDK_INTERP_BILINEAR" value=""/>
+      <member name="GDK_INTERP_HYPER" value=""/>
+    </enum>
+    <enum get-type="gdk_join_style_get_type" name="GdkJoinStyle" type="enum" type-name="GdkJoinStyle">
+      <member name="GDK_JOIN_MITER" value=""/>
+      <member name="GDK_JOIN_ROUND" value=""/>
+      <member name="GDK_JOIN_BEVEL" value=""/>
+    </enum>
+    <enum get-type="gdk_line_style_get_type" name="GdkLineStyle" type="enum" type-name="GdkLineStyle">
+      <member name="GDK_LINE_SOLID" value=""/>
+      <member name="GDK_LINE_ON_OFF_DASH" value=""/>
+      <member name="GDK_LINE_DOUBLE_DASH" value=""/>
+    </enum>
+    <enum get-type="gdk_modifier_type_get_type" name="GdkModifierType" type="flags" type-name="GdkModifierType">
+      <member name="GDK_SHIFT_MASK" value=""/>
+      <member name="GDK_LOCK_MASK" value=""/>
+      <member name="GDK_CONTROL_MASK" value=""/>
+      <member name="GDK_MOD1_MASK" value=""/>
+      <member name="GDK_MOD2_MASK" value=""/>
+      <member name="GDK_MOD3_MASK" value=""/>
+      <member name="GDK_MOD4_MASK" value=""/>
+      <member name="GDK_MOD5_MASK" value=""/>
+      <member name="GDK_BUTTON1_MASK" value=""/>
+      <member name="GDK_BUTTON2_MASK" value=""/>
+      <member name="GDK_BUTTON3_MASK" value=""/>
+      <member name="GDK_BUTTON4_MASK" value=""/>
+      <member name="GDK_BUTTON5_MASK" value=""/>
+      <member name="GDK_SUPER_MASK" value=""/>
+      <member name="GDK_HYPER_MASK" value=""/>
+      <member name="GDK_META_MASK" value=""/>
+      <member name="GDK_RELEASE_MASK" value=""/>
+      <member name="GDK_MODIFIER_MASK" value="0x5c001fff"/>
+    </enum>
+    <enum get-type="gdk_notify_type_get_type" name="GdkNotifyType" type="enum" type-name="GdkNotifyType">
+      <member name="GDK_NOTIFY_ANCESTOR" value="0"/>
+      <member name="GDK_NOTIFY_VIRTUAL" value="1"/>
+      <member name="GDK_NOTIFY_INFERIOR" value="2"/>
+      <member name="GDK_NOTIFY_NONLINEAR" value="3"/>
+      <member name="GDK_NOTIFY_NONLINEAR_VIRTUAL" value="4"/>
+      <member name="GDK_NOTIFY_UNKNOWN" value="5"/>
+    </enum>
+    <enum get-type="gdk_overlap_type_get_type" name="GdkOverlapType" type="enum" type-name="GdkOverlapType">
+      <member name="GDK_OVERLAP_RECTANGLE_IN" value=""/>
+      <member name="GDK_OVERLAP_RECTANGLE_OUT" value=""/>
+      <member name="GDK_OVERLAP_RECTANGLE_PART" value=""/>
+    </enum>
+    <enum get-type="gdk_owner_change_get_type" name="GdkOwnerChange" type="enum" type-name="GdkOwnerChange">
+      <member name="GDK_OWNER_CHANGE_NEW_OWNER" value=""/>
+      <member name="GDK_OWNER_CHANGE_DESTROY" value=""/>
+      <member name="GDK_OWNER_CHANGE_CLOSE" value=""/>
+    </enum>
+    <enum get-type="gdk_pixbuf_alpha_mode_get_type" name="GdkPixbufAlphaMode" type="enum" type-name="GdkPixbufAlphaMode">
+      <member name="GDK_PIXBUF_ALPHA_BILEVEL" value=""/>
+      <member name="GDK_PIXBUF_ALPHA_FULL" value=""/>
+    </enum>
+    <enum get-type="gdk_pixbuf_error_get_type" name="GdkPixbufError" type="enum" type-name="GdkPixbufError">
+      <member name="GDK_PIXBUF_ERROR_CORRUPT_IMAGE" value=""/>
+      <member name="GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY" value=""/>
+      <member name="GDK_PIXBUF_ERROR_BAD_OPTION" value=""/>
+      <member name="GDK_PIXBUF_ERROR_UNKNOWN_TYPE" value=""/>
+      <member name="GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION" value=""/>
+      <member name="GDK_PIXBUF_ERROR_FAILED" value=""/>
+    </enum>
+    <enum name="GdkPixbufFrameAction" type="enum" type-name="GdkPixbufFrameAction">
+      <member name="GDK_PIXBUF_FRAME_RETAIN" value=""/>
+      <member name="GDK_PIXBUF_FRAME_DISPOSE" value=""/>
+      <member name="GDK_PIXBUF_FRAME_REVERT" value=""/>
+    </enum>
+    <enum get-type="gdk_pixbuf_rotation_get_type" name="GdkPixbufRotation" type="enum" type-name="GdkPixbufRotation">
+      <member name="GDK_PIXBUF_ROTATE_NONE" value="0"/>
+      <member name="GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE" value="90"/>
+      <member name="GDK_PIXBUF_ROTATE_UPSIDEDOWN" value="180"/>
+      <member name="GDK_PIXBUF_ROTATE_CLOCKWISE" value="270"/>
+    </enum>
+    <enum name="GdkPixdataDumpType" type="flags" type-name="GdkPixdataDumpType">
+      <member name="GDK_PIXDATA_DUMP_PIXDATA_STREAM" value="0"/>
+      <member name="GDK_PIXDATA_DUMP_PIXDATA_STRUCT" value="1"/>
+      <member name="GDK_PIXDATA_DUMP_MACROS" value="2"/>
+      <member name="GDK_PIXDATA_DUMP_GTYPES" value="0"/>
+      <member name="GDK_PIXDATA_DUMP_CTYPES" value=""/>
+      <member name="GDK_PIXDATA_DUMP_STATIC" value=""/>
+      <member name="GDK_PIXDATA_DUMP_CONST" value=""/>
+      <member name="GDK_PIXDATA_DUMP_RLE_DECODER" value=""/>
+    </enum>
+    <enum name="GdkPixdataType" type="flags" type-name="GdkPixdataType">
+      <member name="GDK_PIXDATA_COLOR_TYPE_RGB" value="0x01"/>
+      <member name="GDK_PIXDATA_COLOR_TYPE_RGBA" value="0x02"/>
+      <member name="GDK_PIXDATA_COLOR_TYPE_MASK" value="0xff"/>
+      <member name="GDK_PIXDATA_SAMPLE_WIDTH_8" value=""/>
+      <member name="GDK_PIXDATA_SAMPLE_WIDTH_MASK" value=""/>
+      <member name="GDK_PIXDATA_ENCODING_RAW" value=""/>
+      <member name="GDK_PIXDATA_ENCODING_RLE" value=""/>
+      <member name="GDK_PIXDATA_ENCODING_MASK" value=""/>
+    </enum>
+    <enum get-type="gdk_prop_mode_get_type" name="GdkPropMode" type="enum" type-name="GdkPropMode">
+      <member name="GDK_PROP_MODE_REPLACE" value=""/>
+      <member name="GDK_PROP_MODE_PREPEND" value=""/>
+      <member name="GDK_PROP_MODE_APPEND" value=""/>
+    </enum>
+    <enum get-type="gdk_property_state_get_type" name="GdkPropertyState" type="enum" type-name="GdkPropertyState">
+      <member name="GDK_PROPERTY_NEW_VALUE" value=""/>
+      <member name="GDK_PROPERTY_DELETE" value=""/>
+    </enum>
+    <enum get-type="gdk_rgb_dither_get_type" name="GdkRgbDither" type="enum" type-name="GdkRgbDither">
+      <member name="GDK_RGB_DITHER_NONE" value=""/>
+      <member name="GDK_RGB_DITHER_NORMAL" value=""/>
+      <member name="GDK_RGB_DITHER_MAX" value=""/>
+    </enum>
+    <enum get-type="gdk_scroll_direction_get_type" name="GdkScrollDirection" type="enum" type-name="GdkScrollDirection">
+      <member name="GDK_SCROLL_UP" value=""/>
+      <member name="GDK_SCROLL_DOWN" value=""/>
+      <member name="GDK_SCROLL_LEFT" value=""/>
+      <member name="GDK_SCROLL_RIGHT" value=""/>
+    </enum>
+    <enum get-type="gdk_setting_action_get_type" name="GdkSettingAction" type="enum" type-name="GdkSettingAction">
+      <member name="GDK_SETTING_ACTION_NEW" value=""/>
+      <member name="GDK_SETTING_ACTION_CHANGED" value=""/>
+      <member name="GDK_SETTING_ACTION_DELETED" value=""/>
+    </enum>
+    <enum get-type="gdk_status_get_type" name="GdkStatus" type="enum" type-name="GdkStatus">
+      <member name="GDK_OK" value="0"/>
+      <member name="GDK_ERROR" value="-1"/>
+      <member name="GDK_ERROR_PARAM" value="-2"/>
+      <member name="GDK_ERROR_FILE" value="-3"/>
+      <member name="GDK_ERROR_MEM" value="-4"/>
+    </enum>
+    <enum get-type="gdk_subwindow_mode_get_type" name="GdkSubwindowMode" type="enum" type-name="GdkSubwindowMode">
+      <member name="GDK_CLIP_BY_CHILDREN" value="0"/>
+      <member name="GDK_INCLUDE_INFERIORS" value="1"/>
+    </enum>
+    <enum get-type="gdk_visibility_state_get_type" name="GdkVisibilityState" type="enum" type-name="GdkVisibilityState">
+      <member name="GDK_VISIBILITY_UNOBSCURED" value=""/>
+      <member name="GDK_VISIBILITY_PARTIAL" value=""/>
+      <member name="GDK_VISIBILITY_FULLY_OBSCURED" value=""/>
+    </enum>
+    <enum get-type="gdk_visual_type_get_type" name="GdkVisualType" type="enum" type-name="GdkVisualType">
+      <member name="GDK_VISUAL_STATIC_GRAY" value=""/>
+      <member name="GDK_VISUAL_GRAYSCALE" value=""/>
+      <member name="GDK_VISUAL_STATIC_COLOR" value=""/>
+      <member name="GDK_VISUAL_PSEUDO_COLOR" value=""/>
+      <member name="GDK_VISUAL_TRUE_COLOR" value=""/>
+      <member name="GDK_VISUAL_DIRECT_COLOR" value=""/>
+    </enum>
+    <enum name="GdkWMDecoration" type="flags" type-name="GdkWMDecoration">
+      <member name="GDK_DECOR_ALL" value=""/>
+      <member name="GDK_DECOR_BORDER" value=""/>
+      <member name="GDK_DECOR_RESIZEH" value=""/>
+      <member name="GDK_DECOR_TITLE" value=""/>
+      <member name="GDK_DECOR_MENU" value=""/>
+      <member name="GDK_DECOR_MINIMIZE" value=""/>
+      <member name="GDK_DECOR_MAXIMIZE" value=""/>
+    </enum>
+    <enum name="GdkWMFunction" type="flags" type-name="GdkWMFunction">
+      <member name="GDK_FUNC_ALL" value=""/>
+      <member name="GDK_FUNC_RESIZE" value=""/>
+      <member name="GDK_FUNC_MOVE" value=""/>
+      <member name="GDK_FUNC_MINIMIZE" value=""/>
+      <member name="GDK_FUNC_MAXIMIZE" value=""/>
+      <member name="GDK_FUNC_CLOSE" value=""/>
+    </enum>
+    <enum get-type="gdk_window_attributes_type_get_type" name="GdkWindowAttributesType" type="flags" type-name="GdkWindowAttributesType">
+      <member name="GDK_WA_TITLE" value=""/>
+      <member name="GDK_WA_X" value=""/>
+      <member name="GDK_WA_Y" value=""/>
+      <member name="GDK_WA_CURSOR" value=""/>
+      <member name="GDK_WA_COLORMAP" value=""/>
+      <member name="GDK_WA_VISUAL" value=""/>
+      <member name="GDK_WA_WMCLASS" value=""/>
+      <member name="GDK_WA_NOREDIR" value=""/>
+    </enum>
+    <enum get-type="gdk_window_class_get_type" name="GdkWindowClass" type="enum" type-name="GdkWindowClass">
+      <member name="GDK_INPUT_OUTPUT" value=""/>
+      <member name="GDK_INPUT_ONLY" value=""/>
+    </enum>
+    <enum get-type="gdk_window_edge_get_type" name="GdkWindowEdge" type="enum" type-name="GdkWindowEdge">
+      <member name="GDK_WINDOW_EDGE_NORTH_WEST" value=""/>
+      <member name="GDK_WINDOW_EDGE_NORTH" value=""/>
+      <member name="GDK_WINDOW_EDGE_NORTH_EAST" value=""/>
+      <member name="GDK_WINDOW_EDGE_WEST" value=""/>
+      <member name="GDK_WINDOW_EDGE_EAST" value=""/>
+      <member name="GDK_WINDOW_EDGE_SOUTH_WEST" value=""/>
+      <member name="GDK_WINDOW_EDGE_SOUTH" value=""/>
+      <member name="GDK_WINDOW_EDGE_SOUTH_EAST" value=""/>
+    </enum>
+    <enum get-type="gdk_window_hints_get_type" name="GdkWindowHints" type="flags" type-name="GdkWindowHints">
+      <member name="GDK_HINT_POS" value=""/>
+      <member name="GDK_HINT_MIN_SIZE" value=""/>
+      <member name="GDK_HINT_MAX_SIZE" value=""/>
+      <member name="GDK_HINT_BASE_SIZE" value=""/>
+      <member name="GDK_HINT_ASPECT" value=""/>
+      <member name="GDK_HINT_RESIZE_INC" value=""/>
+      <member name="GDK_HINT_WIN_GRAVITY" value=""/>
+      <member name="GDK_HINT_USER_POS" value=""/>
+      <member name="GDK_HINT_USER_SIZE" value=""/>
+    </enum>
+    <enum get-type="gdk_window_state_get_type" name="GdkWindowState" type="flags" type-name="GdkWindowState">
+      <member name="GDK_WINDOW_STATE_WITHDRAWN" value=""/>
+      <member name="GDK_WINDOW_STATE_ICONIFIED" value=""/>
+      <member name="GDK_WINDOW_STATE_MAXIMIZED" value=""/>
+      <member name="GDK_WINDOW_STATE_STICKY" value=""/>
+      <member name="GDK_WINDOW_STATE_FULLSCREEN" value=""/>
+      <member name="GDK_WINDOW_STATE_ABOVE" value=""/>
+      <member name="GDK_WINDOW_STATE_BELOW" value=""/>
+    </enum>
+    <enum get-type="gdk_window_type_get_type" name="GdkWindowType" type="enum" type-name="GdkWindowType">
+      <member name="GDK_WINDOW_ROOT" value=""/>
+      <member name="GDK_WINDOW_TOPLEVEL" value=""/>
+      <member name="GDK_WINDOW_CHILD" value=""/>
+      <member name="GDK_WINDOW_DIALOG" value=""/>
+      <member name="GDK_WINDOW_TEMP" value=""/>
+      <member name="GDK_WINDOW_FOREIGN" value=""/>
+    </enum>
+    <enum get-type="gdk_window_type_hint_get_type" name="GdkWindowTypeHint" type="enum" type-name="GdkWindowTypeHint">
+      <member name="GDK_WINDOW_TYPE_HINT_NORMAL" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_DIALOG" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_MENU" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_TOOLBAR" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_SPLASHSCREEN" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_UTILITY" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_DOCK" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_DESKTOP" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_POPUP_MENU" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_TOOLTIP" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_NOTIFICATION" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_COMBO" value=""/>
+      <member name="GDK_WINDOW_TYPE_HINT_DND" value=""/>
+    </enum>
+    <callback name="GdkDestroyNotify" type-name="GdkDestroyNotify">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GdkEventFunc" type-name="GdkEventFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="event" type="GdkEvent*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GdkFilterFunc" type-name="GdkFilterFunc">
+      <return-type type="GdkFilterReturn"/>
+      <parameters>
+        <parameter name="xevent" type="GdkXEvent*"/>
+        <parameter name="event" type="GdkEvent*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GdkInputFunction" type-name="GdkInputFunction">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="data" type="gpointer"/>
+        <parameter name="source" type="gint"/>
+        <parameter name="condition" type="GdkInputCondition"/>
+      </parameters>
+    </callback>
+    <callback name="GdkPixbufDestroyNotify" type-name="GdkPixbufDestroyNotify">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="pixels" type="guchar*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GdkPixbufSaveFunc" type-name="GdkPixbufSaveFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="buf" type="const-gchar*"/>
+        <parameter name="count" type="gsize"/>
+        <parameter name="error" type="GError**"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GdkSpanFunc" type-name="GdkSpanFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="span" type="GdkSpan*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <object get-type="" name="GdkColormap" parent="GObject" type-name="GdkColormap">
+      <field name="size" readable="1" type="gint" writable="1"/>
+      <field name="colors" readable="1" type="GdkColor*" writable="1"/>
+      <field name="visual" type="GdkVisual*"/>
+      <field name="windowing_data" type="gpointer"/>
+      <method name="alloc_color" symbol="gdk_colormap_alloc_color">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="color" type="GdkColor*"/>
+          <parameter name="writeable" type="gboolean"/>
+          <parameter name="best_match" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="alloc_colors" symbol="gdk_colormap_alloc_colors">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="colors" type="GdkColor*"/>
+          <parameter name="ncolors" type="gint"/>
+          <parameter name="writeable" type="gboolean"/>
+          <parameter name="best_match" type="gboolean"/>
+          <parameter name="success" type="gboolean*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="change" symbol="gdk_colormap_change">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="ncolors" type="gint"/>
+        </parameters>
+      </method>
+      <method name="free_colors" symbol="gdk_colormap_free_colors">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="colors" type="GdkColor*"/>
+          <parameter name="ncolors" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gdk_colormap_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="cmap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="get_system" symbol="gdk_colormap_get_system">
+        <return-type type="GdkColormap*"/>
+      </method>
+      <method deprecated="1" name="get_system_size" symbol="gdk_colormap_get_system_size">
+        <return-type type="gint"/>
+      </method>
+      <method name="get_type" symbol="gdk_colormap_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visual" symbol="gdk_colormap_get_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gdk_colormap_new">
+        <parameters>
+          <parameter name="visual" type="GdkVisual*"/>
+          <parameter name="allocate" type="gboolean"/>
+        </parameters>
+      </constructor>
+      <method name="query_color" symbol="gdk_colormap_query_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="pixel" type="gulong"/>
+          <parameter name="result" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="ref" symbol="gdk_colormap_ref">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="cmap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_colormap_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cmap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkDevice" parent="GObject" type-name="GdkDevice">
+      <field name="name" type="gchar*"/>
+      <field name="source" type="GdkInputSource"/>
+      <field name="mode" type="GdkInputMode"/>
+      <field name="has_cursor" type="gboolean"/>
+      <field name="num_axes" type="gint"/>
+      <field name="axes" type="GdkDeviceAxis*"/>
+      <field name="num_keys" type="gint"/>
+      <field name="keys" type="GdkDeviceKey*"/>
+      <method name="free_history" symbol="gdk_device_free_history">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="events" type="GdkTimeCoord**"/>
+          <parameter name="n_events" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_axis" symbol="gdk_device_get_axis">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="axes" type="gdouble*"/>
+          <parameter name="use" type="GdkAxisUse"/>
+          <parameter name="value" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_core_pointer" symbol="gdk_device_get_core_pointer">
+        <return-type type="GdkDevice*"/>
+      </method>
+      <method name="get_history" symbol="gdk_device_get_history">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="start" type="guint32"/>
+          <parameter name="stop" type="guint32"/>
+          <parameter name="events" type="GdkTimeCoord***"/>
+          <parameter name="n_events" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_state" symbol="gdk_device_get_state">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="axes" type="gdouble*"/>
+          <parameter name="mask" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_device_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_axis_use" symbol="gdk_device_set_axis_use">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="index_" type="guint"/>
+          <parameter name="use" type="GdkAxisUse"/>
+        </parameters>
+      </method>
+      <method name="set_key" symbol="gdk_device_set_key">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="index_" type="guint"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="set_mode" symbol="gdk_device_set_mode">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="mode" type="GdkInputMode"/>
+        </parameters>
+      </method>
+      <method name="set_source" symbol="gdk_device_set_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="device" type="GdkDevice*"/>
+          <parameter name="source" type="GdkInputSource"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkDisplay" parent="GObject" type-name="GdkDisplay">
+      <field name="queued_events" type="GList*"/>
+      <field name="queued_tail" type="GList*"/>
+      <field name="button_click_time" type="guint32"/>
+      <field name="button_window" type="GdkWindow*"/>
+      <field name="button_number" type="gint"/>
+      <field name="double_click_time" type="guint"/>
+      <field name="core_pointer" type="GdkDevice*"/>
+      <field name="pointer_hooks" type="const-GdkDisplayPointerHooks*"/>
+      <field name="closed" type="guint"/>
+      <field name="double_click_distance" type="guint"/>
+      <field name="button_x" type="gint"/>
+      <field name="button_y" type="gint"/>
+      <signal name="closed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="is_error" type="gboolean"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_display_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_screens">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="screen_num" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_default_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_client_message_filter" symbol="gdk_display_add_client_message_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="message_type" type="GdkAtom"/>
+          <parameter name="func" type="GdkFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="beep" symbol="gdk_display_beep">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="close" symbol="gdk_display_close">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="flush" symbol="gdk_display_flush">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_core_pointer" symbol="gdk_display_get_core_pointer">
+        <return-type type="GdkDevice*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_default" symbol="gdk_display_get_default">
+        <return-type type="GdkDisplay*"/>
+      </method>
+      <method name="get_default_cursor_size" symbol="gdk_display_get_default_cursor_size">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_default_group" symbol="gdk_display_get_default_group">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_default_screen" symbol="gdk_display_get_default_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_event" symbol="gdk_display_get_event">
+        <return-type type="GdkEvent*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_maximal_cursor_size" symbol="gdk_display_get_maximal_cursor_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="width" type="guint*"/>
+          <parameter name="height" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="get_n_screens" symbol="gdk_display_get_n_screens">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gdk_display_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_pointer" symbol="gdk_display_get_pointer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="screen" type="GdkScreen**"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="mask" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gdk_display_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="screen_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_display_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_window_at_pointer" symbol="gdk_display_get_window_at_pointer">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="win_x" type="gint*"/>
+          <parameter name="win_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="keyboard_ungrab" symbol="gdk_display_keyboard_ungrab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="list_devices" symbol="gdk_display_list_devices">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="open" symbol="gdk_display_open">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="display_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="open_default_libgtk_only" symbol="gdk_display_open_default_libgtk_only">
+        <return-type type="GdkDisplay*"/>
+      </method>
+      <method name="peek_event" symbol="gdk_display_peek_event">
+        <return-type type="GdkEvent*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="pointer_is_grabbed" symbol="gdk_display_pointer_is_grabbed">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="pointer_ungrab" symbol="gdk_display_pointer_ungrab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="put_event" symbol="gdk_display_put_event">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="request_selection_notification" symbol="gdk_display_request_selection_notification">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="set_double_click_distance" symbol="gdk_display_set_double_click_distance">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="distance" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_double_click_time" symbol="gdk_display_set_double_click_time">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="msec" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_pointer_hooks" symbol="gdk_display_set_pointer_hooks">
+        <return-type type="GdkDisplayPointerHooks*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="new_hooks" type="const-GdkDisplayPointerHooks*"/>
+        </parameters>
+      </method>
+      <method name="store_clipboard" symbol="gdk_display_store_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="clipboard_window" type="GdkWindow*"/>
+          <parameter name="time_" type="guint32"/>
+          <parameter name="targets" type="GdkAtom*"/>
+          <parameter name="n_targets" type="gint"/>
+        </parameters>
+      </method>
+      <method name="supports_clipboard_persistence" symbol="gdk_display_supports_clipboard_persistence">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="supports_cursor_alpha" symbol="gdk_display_supports_cursor_alpha">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="supports_cursor_color" symbol="gdk_display_supports_cursor_color">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="supports_input_shapes" symbol="gdk_display_supports_input_shapes">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="supports_selection_notification" symbol="gdk_display_supports_selection_notification">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="supports_shapes" symbol="gdk_display_supports_shapes">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="sync" symbol="gdk_display_sync">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="warp_pointer" symbol="gdk_display_warp_pointer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkDisplayManager" parent="GObject" type-name="GdkDisplayManager">
+      <signal name="display_opened" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display_manager" type="GdkDisplayManager*"/>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </signal>
+      <property name="default-display" readable="1" type="GdkDisplay" writable="1"/>
+      <method name="get" symbol="gdk_display_manager_get">
+        <return-type type="GdkDisplayManager*"/>
+      </method>
+      <method name="get_default_display" symbol="gdk_display_manager_get_default_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="display_manager" type="GdkDisplayManager*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_display_manager_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="list_displays" symbol="gdk_display_manager_list_displays">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="display_manager" type="GdkDisplayManager*"/>
+        </parameters>
+      </method>
+      <method name="set_default_display" symbol="gdk_display_manager_set_default_display">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display_manager" type="GdkDisplayManager*"/>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkDragContext" parent="GObject" type-name="GdkDragContext">
+      <field name="protocol" readable="1" type="GdkDragProtocol" writable="1"/>
+      <field name="is_source" readable="1" type="gboolean" writable="1"/>
+      <field name="source_window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="dest_window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="targets" readable="1" type="GList*" writable="1"/>
+      <field name="actions" readable="1" type="GdkDragAction" writable="1"/>
+      <field name="suggested_action" readable="1" type="GdkDragAction" writable="1"/>
+      <field name="action" readable="1" type="GdkDragAction" writable="1"/>
+      <field name="start_time" readable="1" type="guint32" writable="1"/>
+      <field name="windowing_data" type="gpointer"/>
+      <method name="get_type" symbol="gdk_drag_context_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gdk_drag_context_new"/>
+      <method deprecated="1" name="ref" symbol="gdk_drag_context_ref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_drag_context_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkDrawable" parent="GObject" type-name="GdkDrawable">
+      <vfunc name="create_gc">
+        <return-type type="GdkGC*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+          <parameter name="mask" type="GdkGCValuesMask"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_rectangle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="filled" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_arc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="filled" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="angle1" type="gint"/>
+          <parameter name="angle2" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_polygon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="filled" type="gboolean"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_text_wc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="text" type="const-GdkWChar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_drawable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="src" type="GdkDrawable*"/>
+          <parameter name="xsrc" type="gint"/>
+          <parameter name="ysrc" type="gint"/>
+          <parameter name="xdest" type="gint"/>
+          <parameter name="ydest" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_points">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_segments">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="segs" type="GdkSegment*"/>
+          <parameter name="nsegs" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_lines">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_glyphs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="xsrc" type="gint"/>
+          <parameter name="ysrc" type="gint"/>
+          <parameter name="xdest" type="gint"/>
+          <parameter name="ydest" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_depth">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="cmap" type="GdkColormap*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_image">
+        <return-type type="GdkImage*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_clip_region">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_visible_region">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_composite_drawable">
+        <return-type type="GdkDrawable*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="composite_x_offset" type="gint*"/>
+          <parameter name="composite_y_offset" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="src_x" type="gint"/>
+          <parameter name="src_y" type="gint"/>
+          <parameter name="dest_x" type="gint"/>
+          <parameter name="dest_y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dither" type="GdkRgbDither"/>
+          <parameter name="x_dither" type="gint"/>
+          <parameter name="y_dither" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="_copy_to_image">
+        <return-type type="GdkImage*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="src_x" type="gint"/>
+          <parameter name="src_y" type="gint"/>
+          <parameter name="dest_x" type="gint"/>
+          <parameter name="dest_y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_glyphs_transformed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="matrix" type="PangoMatrix*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_trapezoids">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="trapezoids" type="GdkTrapezoid*"/>
+          <parameter name="n_trapezoids" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_cairo_surface">
+        <return-type type="cairo_surface_t*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </vfunc>
+      <method name="draw_arc" symbol="gdk_draw_arc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="filled" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="angle1" type="gint"/>
+          <parameter name="angle2" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_drawable" symbol="gdk_draw_drawable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="src" type="GdkDrawable*"/>
+          <parameter name="xsrc" type="gint"/>
+          <parameter name="ysrc" type="gint"/>
+          <parameter name="xdest" type="gint"/>
+          <parameter name="ydest" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_glyphs" symbol="gdk_draw_glyphs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+        </parameters>
+      </method>
+      <method name="draw_glyphs_transformed" symbol="gdk_draw_glyphs_transformed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="matrix" type="PangoMatrix*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+        </parameters>
+      </method>
+      <method name="draw_gray_image" symbol="gdk_draw_gray_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dith" type="GdkRgbDither"/>
+          <parameter name="buf" type="guchar*"/>
+          <parameter name="rowstride" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_image" symbol="gdk_draw_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="xsrc" type="gint"/>
+          <parameter name="ysrc" type="gint"/>
+          <parameter name="xdest" type="gint"/>
+          <parameter name="ydest" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_indexed_image" symbol="gdk_draw_indexed_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dith" type="GdkRgbDither"/>
+          <parameter name="buf" type="guchar*"/>
+          <parameter name="rowstride" type="gint"/>
+          <parameter name="cmap" type="GdkRgbCmap*"/>
+        </parameters>
+      </method>
+      <method name="draw_layout" symbol="gdk_draw_layout">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="draw_layout_line" symbol="gdk_draw_layout_line">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="line" type="PangoLayoutLine*"/>
+        </parameters>
+      </method>
+      <method name="draw_layout_line_with_colors" symbol="gdk_draw_layout_line_with_colors">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="foreground" type="const-GdkColor*"/>
+          <parameter name="background" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="draw_layout_with_colors" symbol="gdk_draw_layout_with_colors">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="foreground" type="const-GdkColor*"/>
+          <parameter name="background" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="draw_line" symbol="gdk_draw_line">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x1_" type="gint"/>
+          <parameter name="y1_" type="gint"/>
+          <parameter name="x2_" type="gint"/>
+          <parameter name="y2_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_lines" symbol="gdk_draw_lines">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_pixbuf" symbol="gdk_draw_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="src_x" type="gint"/>
+          <parameter name="src_y" type="gint"/>
+          <parameter name="dest_x" type="gint"/>
+          <parameter name="dest_y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dither" type="GdkRgbDither"/>
+          <parameter name="x_dither" type="gint"/>
+          <parameter name="y_dither" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_point" symbol="gdk_draw_point">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_points" symbol="gdk_draw_points">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_polygon" symbol="gdk_draw_polygon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="filled" type="gboolean"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_rectangle" symbol="gdk_draw_rectangle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="filled" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_rgb_32_image" symbol="gdk_draw_rgb_32_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dith" type="GdkRgbDither"/>
+          <parameter name="buf" type="guchar*"/>
+          <parameter name="rowstride" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_rgb_32_image_dithalign" symbol="gdk_draw_rgb_32_image_dithalign">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dith" type="GdkRgbDither"/>
+          <parameter name="buf" type="guchar*"/>
+          <parameter name="rowstride" type="gint"/>
+          <parameter name="xdith" type="gint"/>
+          <parameter name="ydith" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_rgb_image" symbol="gdk_draw_rgb_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dith" type="GdkRgbDither"/>
+          <parameter name="rgb_buf" type="guchar*"/>
+          <parameter name="rowstride" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_rgb_image_dithalign" symbol="gdk_draw_rgb_image_dithalign">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="dith" type="GdkRgbDither"/>
+          <parameter name="rgb_buf" type="guchar*"/>
+          <parameter name="rowstride" type="gint"/>
+          <parameter name="xdith" type="gint"/>
+          <parameter name="ydith" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_segments" symbol="gdk_draw_segments">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="segs" type="GdkSegment*"/>
+          <parameter name="nsegs" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="draw_string" symbol="gdk_draw_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="draw_text" symbol="gdk_draw_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="draw_text_wc" symbol="gdk_draw_text_wc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="text" type="const-GdkWChar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </method>
+      <method name="draw_trapezoids" symbol="gdk_draw_trapezoids">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="trapezoids" type="GdkTrapezoid*"/>
+          <parameter name="n_trapezoids" type="gint"/>
+        </parameters>
+      </method>
+      <method name="copy_to_image" symbol="gdk_drawable_copy_to_image">
+        <return-type type="GdkImage*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="src_x" type="gint"/>
+          <parameter name="src_y" type="gint"/>
+          <parameter name="dest_x" type="gint"/>
+          <parameter name="dest_y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_clip_region" symbol="gdk_drawable_get_clip_region">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="get_colormap" symbol="gdk_drawable_get_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_data" symbol="gdk_drawable_get_data">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_depth" symbol="gdk_drawable_get_depth">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="get_display" symbol="gdk_drawable_get_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="get_image" symbol="gdk_drawable_get_image">
+        <return-type type="GdkImage*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gdk_drawable_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gdk_drawable_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_drawable_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible_region" symbol="gdk_drawable_get_visible_region">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="get_visual" symbol="gdk_drawable_get_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="ref" symbol="gdk_drawable_ref">
+        <return-type type="GdkDrawable*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="set_colormap" symbol="gdk_drawable_set_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_data" symbol="gdk_drawable_set_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy_func" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_drawable_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkGC" parent="GObject" type-name="GdkGC">
+      <field name="clip_x_origin" type="gint"/>
+      <field name="clip_y_origin" type="gint"/>
+      <field name="ts_x_origin" type="gint"/>
+      <field name="ts_y_origin" type="gint"/>
+      <field name="colormap" type="GdkColormap*"/>
+      <vfunc name="get_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+          <parameter name="mask" type="GdkGCValuesMask"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_dashes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="dash_offset" type="gint"/>
+          <parameter name="dash_list" type="gint8[]"/>
+          <parameter name="n" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="copy" symbol="gdk_gc_copy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dst_gc" type="GdkGC*"/>
+          <parameter name="src_gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+      <method name="get_colormap" symbol="gdk_gc_get_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gdk_gc_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_gc_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_values" symbol="gdk_gc_get_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gdk_gc_new">
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_values" symbol="gdk_gc_new_with_values">
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+          <parameter name="values_mask" type="GdkGCValuesMask"/>
+        </parameters>
+      </constructor>
+      <method name="offset" symbol="gdk_gc_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x_offset" type="gint"/>
+          <parameter name="y_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="ref" symbol="gdk_gc_ref">
+        <return-type type="GdkGC*"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+      <method name="set_background" symbol="gdk_gc_set_background">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_clip_mask" symbol="gdk_gc_set_clip_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+      <method name="set_clip_origin" symbol="gdk_gc_set_clip_origin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_clip_rectangle" symbol="gdk_gc_set_clip_rectangle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="set_clip_region" symbol="gdk_gc_set_clip_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="set_colormap" symbol="gdk_gc_set_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="set_dashes" symbol="gdk_gc_set_dashes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="dash_offset" type="gint"/>
+          <parameter name="dash_list" type="gint8[]"/>
+          <parameter name="n" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_exposures" symbol="gdk_gc_set_exposures">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="exposures" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_fill" symbol="gdk_gc_set_fill">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="fill" type="GdkFill"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_font" symbol="gdk_gc_set_font">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="font" type="GdkFont*"/>
+        </parameters>
+      </method>
+      <method name="set_foreground" symbol="gdk_gc_set_foreground">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_function" symbol="gdk_gc_set_function">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="function" type="GdkFunction"/>
+        </parameters>
+      </method>
+      <method name="set_line_attributes" symbol="gdk_gc_set_line_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="line_width" type="gint"/>
+          <parameter name="line_style" type="GdkLineStyle"/>
+          <parameter name="cap_style" type="GdkCapStyle"/>
+          <parameter name="join_style" type="GdkJoinStyle"/>
+        </parameters>
+      </method>
+      <method name="set_rgb_bg_color" symbol="gdk_gc_set_rgb_bg_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_rgb_fg_color" symbol="gdk_gc_set_rgb_fg_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_stipple" symbol="gdk_gc_set_stipple">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="stipple" type="GdkPixmap*"/>
+        </parameters>
+      </method>
+      <method name="set_subwindow" symbol="gdk_gc_set_subwindow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="mode" type="GdkSubwindowMode"/>
+        </parameters>
+      </method>
+      <method name="set_tile" symbol="gdk_gc_set_tile">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="tile" type="GdkPixmap*"/>
+        </parameters>
+      </method>
+      <method name="set_ts_origin" symbol="gdk_gc_set_ts_origin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_values" symbol="gdk_gc_set_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+          <parameter name="values_mask" type="GdkGCValuesMask"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_gc_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkImage" parent="GObject" type-name="GdkImage">
+      <field name="type" readable="1" type="GdkImageType" writable="1"/>
+      <field name="visual" readable="1" type="GdkVisual*" writable="1"/>
+      <field name="byte_order" readable="1" type="GdkByteOrder" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+      <field name="depth" readable="1" type="guint16" writable="1"/>
+      <field name="bpp" readable="1" type="guint16" writable="1"/>
+      <field name="bpl" readable="1" type="guint16" writable="1"/>
+      <field name="bits_per_pixel" readable="1" type="guint16" writable="1"/>
+      <field name="mem" readable="1" type="gpointer" writable="1"/>
+      <field name="colormap" readable="1" type="GdkColormap*" writable="1"/>
+      <field name="windowing_data" type="gpointer"/>
+      <method deprecated="1" name="get" symbol="gdk_image_get">
+        <return-type type="GdkImage*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_colormap" symbol="gdk_image_get_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_pixel" symbol="gdk_image_get_pixel">
+        <return-type type="guint32"/>
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_image_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gdk_image_new">
+        <parameters>
+          <parameter name="type" type="GdkImageType"/>
+          <parameter name="visual" type="GdkVisual*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </constructor>
+      <method name="put_pixel" symbol="gdk_image_put_pixel">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="pixel" type="guint32"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="ref" symbol="gdk_image_ref">
+        <return-type type="GdkImage*"/>
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+        </parameters>
+      </method>
+      <method name="set_colormap" symbol="gdk_image_set_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_image_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkKeymap" parent="GObject" type-name="GdkKeymap">
+      <field name="display" type="GdkDisplay*"/>
+      <signal name="direction_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+        </parameters>
+      </signal>
+      <signal name="keys_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+        </parameters>
+      </signal>
+      <method name="get_default" symbol="gdk_keymap_get_default">
+        <return-type type="GdkKeymap*"/>
+      </method>
+      <method name="get_direction" symbol="gdk_keymap_get_direction">
+        <return-type type="PangoDirection"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+        </parameters>
+      </method>
+      <method name="get_entries_for_keycode" symbol="gdk_keymap_get_entries_for_keycode">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+          <parameter name="hardware_keycode" type="guint"/>
+          <parameter name="keys" type="GdkKeymapKey**"/>
+          <parameter name="keyvals" type="guint**"/>
+          <parameter name="n_entries" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_entries_for_keyval" symbol="gdk_keymap_get_entries_for_keyval">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="keys" type="GdkKeymapKey**"/>
+          <parameter name="n_keys" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_for_display" symbol="gdk_keymap_get_for_display">
+        <return-type type="GdkKeymap*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_keymap_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="lookup_key" symbol="gdk_keymap_lookup_key">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+          <parameter name="key" type="const-GdkKeymapKey*"/>
+        </parameters>
+      </method>
+      <method name="translate_keyboard_state" symbol="gdk_keymap_translate_keyboard_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="keymap" type="GdkKeymap*"/>
+          <parameter name="hardware_keycode" type="guint"/>
+          <parameter name="state" type="GdkModifierType"/>
+          <parameter name="group" type="gint"/>
+          <parameter name="keyval" type="guint*"/>
+          <parameter name="effective_group" type="gint*"/>
+          <parameter name="level" type="gint*"/>
+          <parameter name="consumed_modifiers" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkPangoRenderer" parent="PangoRenderer" type-name="GdkPangoRenderer">
+      <field name="priv" type="GdkPangoRendererPrivate*"/>
+      <property construct-only="1" name="screen" readable="1" type="GdkScreen" writable="1"/>
+      <method name="get_default" symbol="gdk_pango_renderer_get_default">
+        <return-type type="PangoRenderer*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pango_renderer_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gdk_pango_renderer_new">
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </constructor>
+      <method name="set_drawable" symbol="gdk_pango_renderer_set_drawable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gdk_renderer" type="GdkPangoRenderer*"/>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="set_gc" symbol="gdk_pango_renderer_set_gc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gdk_renderer" type="GdkPangoRenderer*"/>
+          <parameter name="gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+      <method name="set_override_color" symbol="gdk_pango_renderer_set_override_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gdk_renderer" type="GdkPangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_stipple" symbol="gdk_pango_renderer_set_stipple">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gdk_renderer" type="GdkPangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="stipple" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbuf" parent="GObject" type-name="GdkPixbuf">
+      <property name="n-channels" type="gint"/>
+      <property name="colorspace" type="GdkColorspace"/>
+      <property name="has-alpha" type="gboolean"/>
+      <property name="bits-per-sample" type="gint"/>
+      <property name="width" type="gint"/>
+      <property name="height" type="gint"/>
+      <property name="rowstride" type="gint"/>
+      <property name="pixels" type="gpointer"/>
+      <method name="add_alpha" symbol="gdk_pixbuf_add_alpha">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+          <parameter name="substitute_color" type="gboolean"/>
+          <parameter name="r" type="guchar"/>
+          <parameter name="g" type="guchar"/>
+          <parameter name="b" type="guchar"/>
+        </parameters>
+      </method>
+      <method name="composite" symbol="gdk_pixbuf_composite">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="dest" type="GdkPixbuf*"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="dest_width" type="int"/>
+          <parameter name="dest_height" type="int"/>
+          <parameter name="offset_x" type="double"/>
+          <parameter name="offset_y" type="double"/>
+          <parameter name="scale_x" type="double"/>
+          <parameter name="scale_y" type="double"/>
+          <parameter name="interp_type" type="GdkInterpType"/>
+          <parameter name="overall_alpha" type="int"/>
+        </parameters>
+      </method>
+      <method name="composite_color" symbol="gdk_pixbuf_composite_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="dest" type="GdkPixbuf*"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="dest_width" type="int"/>
+          <parameter name="dest_height" type="int"/>
+          <parameter name="offset_x" type="double"/>
+          <parameter name="offset_y" type="double"/>
+          <parameter name="scale_x" type="double"/>
+          <parameter name="scale_y" type="double"/>
+          <parameter name="interp_type" type="GdkInterpType"/>
+          <parameter name="overall_alpha" type="int"/>
+          <parameter name="check_x" type="int"/>
+          <parameter name="check_y" type="int"/>
+          <parameter name="check_size" type="int"/>
+          <parameter name="color1" type="guint32"/>
+          <parameter name="color2" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="composite_color_simple" symbol="gdk_pixbuf_composite_color_simple">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="dest_width" type="int"/>
+          <parameter name="dest_height" type="int"/>
+          <parameter name="interp_type" type="GdkInterpType"/>
+          <parameter name="overall_alpha" type="int"/>
+          <parameter name="check_size" type="int"/>
+          <parameter name="color1" type="guint32"/>
+          <parameter name="color2" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="gdk_pixbuf_copy">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="copy_area" symbol="gdk_pixbuf_copy_area">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src_pixbuf" type="const-GdkPixbuf*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="dest_pixbuf" type="GdkPixbuf*"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+        </parameters>
+      </method>
+      <method name="error_quark" symbol="gdk_pixbuf_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="fill" symbol="gdk_pixbuf_fill">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="pixel" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="flip" symbol="gdk_pixbuf_flip">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="horizontal" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="from_pixdata" symbol="gdk_pixbuf_from_pixdata">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="pixdata" type="const-GdkPixdata*"/>
+          <parameter name="copy_pixels" type="gboolean"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="get_bits_per_sample" symbol="gdk_pixbuf_get_bits_per_sample">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_colorspace" symbol="gdk_pixbuf_get_colorspace">
+        <return-type type="GdkColorspace"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_file_info" symbol="gdk_pixbuf_get_file_info">
+        <return-type type="GdkPixbufFormat*"/>
+        <parameters>
+          <parameter name="filename" type="const-gchar*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_formats" symbol="gdk_pixbuf_get_formats">
+        <return-type type="GSList*"/>
+      </method>
+      <method name="get_from_drawable" symbol="gdk_pixbuf_get_from_drawable">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="dest" type="GdkPixbuf*"/>
+          <parameter name="src" type="GdkDrawable*"/>
+          <parameter name="cmap" type="GdkColormap*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </method>
+      <method name="get_from_image" symbol="gdk_pixbuf_get_from_image">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="dest" type="GdkPixbuf*"/>
+          <parameter name="src" type="GdkImage*"/>
+          <parameter name="cmap" type="GdkColormap*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </method>
+      <method name="get_has_alpha" symbol="gdk_pixbuf_get_has_alpha">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_height" symbol="gdk_pixbuf_get_height">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_n_channels" symbol="gdk_pixbuf_get_n_channels">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_option" symbol="gdk_pixbuf_get_option">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_pixels" symbol="gdk_pixbuf_get_pixels">
+        <return-type type="guchar*"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_rowstride" symbol="gdk_pixbuf_get_rowstride">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixbuf_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="gdk_pixbuf_get_width">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gdk_pixbuf_new">
+        <parameters>
+          <parameter name="colorspace" type="GdkColorspace"/>
+          <parameter name="has_alpha" type="gboolean"/>
+          <parameter name="bits_per_sample" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_data" symbol="gdk_pixbuf_new_from_data">
+        <parameters>
+          <parameter name="data" type="const-guchar*"/>
+          <parameter name="colorspace" type="GdkColorspace"/>
+          <parameter name="has_alpha" type="gboolean"/>
+          <parameter name="bits_per_sample" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="rowstride" type="int"/>
+          <parameter name="destroy_fn" type="GdkPixbufDestroyNotify"/>
+          <parameter name="destroy_fn_data" type="gpointer"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_file" symbol="gdk_pixbuf_new_from_file">
+        <parameters>
+          <parameter name="filename" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_file_at_scale" symbol="gdk_pixbuf_new_from_file_at_scale">
+        <parameters>
+          <parameter name="filename" type="const-char*"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="preserve_aspect_ratio" type="gboolean"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_file_at_size" symbol="gdk_pixbuf_new_from_file_at_size">
+        <parameters>
+          <parameter name="filename" type="const-char*"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_inline" symbol="gdk_pixbuf_new_from_inline">
+        <parameters>
+          <parameter name="data_length" type="gint"/>
+          <parameter name="data" type="const-guint8*"/>
+          <parameter name="copy_pixels" type="gboolean"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_xpm_data" symbol="gdk_pixbuf_new_from_xpm_data">
+        <parameters>
+          <parameter name="data" type="const-char**"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_subpixbuf" symbol="gdk_pixbuf_new_subpixbuf">
+        <parameters>
+          <parameter name="src_pixbuf" type="GdkPixbuf*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="ref" symbol="gdk_pixbuf_ref">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="render_pixmap_and_mask" symbol="gdk_pixbuf_render_pixmap_and_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="pixmap_return" type="GdkPixmap**"/>
+          <parameter name="mask_return" type="GdkBitmap**"/>
+          <parameter name="alpha_threshold" type="int"/>
+        </parameters>
+      </method>
+      <method name="render_pixmap_and_mask_for_colormap" symbol="gdk_pixbuf_render_pixmap_and_mask_for_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="pixmap_return" type="GdkPixmap**"/>
+          <parameter name="mask_return" type="GdkBitmap**"/>
+          <parameter name="alpha_threshold" type="int"/>
+        </parameters>
+      </method>
+      <method name="render_threshold_alpha" symbol="gdk_pixbuf_render_threshold_alpha">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="bitmap" type="GdkBitmap*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="alpha_threshold" type="int"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="render_to_drawable" symbol="gdk_pixbuf_render_to_drawable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="dither" type="GdkRgbDither"/>
+          <parameter name="x_dither" type="int"/>
+          <parameter name="y_dither" type="int"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="render_to_drawable_alpha" symbol="gdk_pixbuf_render_to_drawable_alpha">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="src_x" type="int"/>
+          <parameter name="src_y" type="int"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+          <parameter name="alpha_mode" type="GdkPixbufAlphaMode"/>
+          <parameter name="alpha_threshold" type="int"/>
+          <parameter name="dither" type="GdkRgbDither"/>
+          <parameter name="x_dither" type="int"/>
+          <parameter name="y_dither" type="int"/>
+        </parameters>
+      </method>
+      <method name="rotate_simple" symbol="gdk_pixbuf_rotate_simple">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="angle" type="GdkPixbufRotation"/>
+        </parameters>
+      </method>
+      <method name="saturate_and_pixelate" symbol="gdk_pixbuf_saturate_and_pixelate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="dest" type="GdkPixbuf*"/>
+          <parameter name="saturation" type="gfloat"/>
+          <parameter name="pixelate" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="save" symbol="gdk_pixbuf_save">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="filename" type="const-char*"/>
+          <parameter name="type" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="save_to_buffer" symbol="gdk_pixbuf_save_to_buffer">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="buffer" type="gchar**"/>
+          <parameter name="buffer_size" type="gsize*"/>
+          <parameter name="type" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="save_to_bufferv" symbol="gdk_pixbuf_save_to_bufferv">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="buffer" type="gchar**"/>
+          <parameter name="buffer_size" type="gsize*"/>
+          <parameter name="type" type="const-char*"/>
+          <parameter name="option_keys" type="char**"/>
+          <parameter name="option_values" type="char**"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="save_to_callback" symbol="gdk_pixbuf_save_to_callback">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="save_func" type="GdkPixbufSaveFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="type" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="save_to_callbackv" symbol="gdk_pixbuf_save_to_callbackv">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="save_func" type="GdkPixbufSaveFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="type" type="const-char*"/>
+          <parameter name="option_keys" type="char**"/>
+          <parameter name="option_values" type="char**"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="savev" symbol="gdk_pixbuf_savev">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="filename" type="const-char*"/>
+          <parameter name="type" type="const-char*"/>
+          <parameter name="option_keys" type="char**"/>
+          <parameter name="option_values" type="char**"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="scale" symbol="gdk_pixbuf_scale">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="dest" type="GdkPixbuf*"/>
+          <parameter name="dest_x" type="int"/>
+          <parameter name="dest_y" type="int"/>
+          <parameter name="dest_width" type="int"/>
+          <parameter name="dest_height" type="int"/>
+          <parameter name="offset_x" type="double"/>
+          <parameter name="offset_y" type="double"/>
+          <parameter name="scale_x" type="double"/>
+          <parameter name="scale_y" type="double"/>
+          <parameter name="interp_type" type="GdkInterpType"/>
+        </parameters>
+      </method>
+      <method name="scale_simple" symbol="gdk_pixbuf_scale_simple">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="src" type="const-GdkPixbuf*"/>
+          <parameter name="dest_width" type="int"/>
+          <parameter name="dest_height" type="int"/>
+          <parameter name="interp_type" type="GdkInterpType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_pixbuf_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufAnimation" parent="GObject" type-name="GdkPixbufAnimation">
+      <method name="get_height" symbol="gdk_pixbuf_animation_get_height">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+      <method name="get_iter" symbol="gdk_pixbuf_animation_get_iter">
+        <return-type type="GdkPixbufAnimationIter*"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+          <parameter name="start_time" type="const-GTimeVal*"/>
+        </parameters>
+      </method>
+      <method name="get_static_image" symbol="gdk_pixbuf_animation_get_static_image">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixbuf_animation_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="gdk_pixbuf_animation_get_width">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+      <method name="is_static_image" symbol="gdk_pixbuf_animation_is_static_image">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+      <constructor name="new_from_file" symbol="gdk_pixbuf_animation_new_from_file">
+        <parameters>
+          <parameter name="filename" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="ref" symbol="gdk_pixbuf_animation_ref">
+        <return-type type="GdkPixbufAnimation*"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_pixbuf_animation_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufAnimationIter" parent="GObject" type-name="GdkPixbufAnimationIter">
+      <method name="advance" symbol="gdk_pixbuf_animation_iter_advance">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GdkPixbufAnimationIter*"/>
+          <parameter name="current_time" type="const-GTimeVal*"/>
+        </parameters>
+      </method>
+      <method name="get_delay_time" symbol="gdk_pixbuf_animation_iter_get_delay_time">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="iter" type="GdkPixbufAnimationIter*"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gdk_pixbuf_animation_iter_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="iter" type="GdkPixbufAnimationIter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixbuf_animation_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="on_currently_loading_frame" symbol="gdk_pixbuf_animation_iter_on_currently_loading_frame">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GdkPixbufAnimationIter*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufAniAnim" parent="GdkPixbufAnimation" type-name="GdkPixbufAniAnim">
+      <field name="total_time" type="int"/>
+      <field name="n_frames" type="int"/>
+      <field name="n_pixbufs" type="int"/>
+      <field name="pixbufs" type="GdkPixbuf**"/>
+      <field name="sequence" type="int*"/>
+      <field name="delay" type="int*"/>
+      <field name="width" type="int"/>
+      <field name="height" type="int"/>
+      <method name="get_type" symbol="gdk_pixbuf_ani_anim_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufAniAnimIter" parent="GdkPixbufAnimationIter" type-name="GdkPixbufAniAnimIter">
+      <field name="ani_anim" type="GdkPixbufAniAnim*"/>
+      <field name="start_time" type="GTimeVal"/>
+      <field name="current_time" type="GTimeVal"/>
+      <field name="position" type="gint"/>
+      <field name="current_frame" type="gint"/>
+      <field name="elapsed" type="gint"/>
+      <method name="get_type" symbol="gdk_pixbuf_ani_anim_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufGifAnim" parent="GdkPixbufAnimation" type-name="GdkPixbufGifAnim">
+      <field name="n_frames" type="int"/>
+      <field name="total_time" type="int"/>
+      <field name="frames" type="GList*"/>
+      <field name="width" type="int"/>
+      <field name="height" type="int"/>
+      <field name="bg_red" type="guchar"/>
+      <field name="bg_green" type="guchar"/>
+      <field name="bg_blue" type="guchar"/>
+      <field name="loop" type="int"/>
+      <field name="loading" type="gboolean"/>
+      <method name="frame_composite" symbol="gdk_pixbuf_gif_anim_frame_composite">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gif_anim" type="GdkPixbufGifAnim*"/>
+          <parameter name="frame" type="GdkPixbufFrame*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixbuf_gif_anim_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufGifAnimIter" parent="GdkPixbufAnimationIter" type-name="GdkPixbufGifAnimIter">
+      <field name="gif_anim" type="GdkPixbufGifAnim*"/>
+      <field name="start_time" type="GTimeVal"/>
+      <field name="current_time" type="GTimeVal"/>
+      <field name="position" type="gint"/>
+      <field name="current_frame" type="GList*"/>
+      <field name="first_loop_slowness" type="gint"/>
+      <method name="get_type" symbol="gdk_pixbuf_gif_anim_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufLoader" parent="GObject" type-name="GdkPixbufLoader">
+      <field name="priv" type="gpointer"/>
+      <signal name="size_prepared" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </signal>
+      <signal name="area_prepared" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+        </parameters>
+      </signal>
+      <signal name="area_updated" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </signal>
+      <signal name="closed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+        </parameters>
+      </signal>
+      <method name="close" symbol="gdk_pixbuf_loader_close">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="get_animation" symbol="gdk_pixbuf_loader_get_animation">
+        <return-type type="GdkPixbufAnimation*"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+        </parameters>
+      </method>
+      <method name="get_format" symbol="gdk_pixbuf_loader_get_format">
+        <return-type type="GdkPixbufFormat*"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gdk_pixbuf_loader_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixbuf_loader_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gdk_pixbuf_loader_new"/>
+      <constructor name="new_with_mime_type" symbol="gdk_pixbuf_loader_new_with_mime_type">
+        <parameters>
+          <parameter name="mime_type" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_type" symbol="gdk_pixbuf_loader_new_with_type">
+        <parameters>
+          <parameter name="image_type" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </constructor>
+      <method name="set_size" symbol="gdk_pixbuf_loader_set_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </method>
+      <method name="write" symbol="gdk_pixbuf_loader_write">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="loader" type="GdkPixbufLoader*"/>
+          <parameter name="buf" type="const-guchar*"/>
+          <parameter name="count" type="gsize"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GdkPixbufSimpleAnim" parent="GdkPixbufAnimation" type-name="GdkPixbufSimpleAnim">
+      <method name="add_frame" symbol="gdk_pixbuf_simple_anim_add_frame">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="animation" type="GdkPixbufSimpleAnim*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixbuf_simple_anim_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="iter_get_type" symbol="gdk_pixbuf_simple_anim_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gdk_pixbuf_simple_anim_new">
+        <parameters>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="rate" type="gfloat"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GdkPixmap" parent="GObject" type-name="GdkPixmap">
+      <method name="colormap_create_from_xpm" symbol="gdk_pixmap_colormap_create_from_xpm">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+          <parameter name="transparent_color" type="const-GdkColor*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="colormap_create_from_xpm_d" symbol="gdk_pixmap_colormap_create_from_xpm_d">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+          <parameter name="transparent_color" type="const-GdkColor*"/>
+          <parameter name="data" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="create_from_data" symbol="gdk_pixmap_create_from_data">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="data" type="const-gchar*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="depth" type="gint"/>
+          <parameter name="fg" type="const-GdkColor*"/>
+          <parameter name="bg" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="create_from_xpm" symbol="gdk_pixmap_create_from_xpm">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+          <parameter name="transparent_color" type="const-GdkColor*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="create_from_xpm_d" symbol="gdk_pixmap_create_from_xpm_d">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+          <parameter name="transparent_color" type="const-GdkColor*"/>
+          <parameter name="data" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="foreign_new" symbol="gdk_pixmap_foreign_new">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="foreign_new_for_display" symbol="gdk_pixmap_foreign_new_for_display">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="foreign_new_for_screen" symbol="gdk_pixmap_foreign_new_for_screen">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="anid" type="GdkNativeWindow"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="depth" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_pixmap_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="lookup" symbol="gdk_pixmap_lookup">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="lookup_for_display" symbol="gdk_pixmap_lookup_for_display">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gdk_pixmap_new">
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="depth" type="gint"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GdkScreen" parent="GObject" type-name="GdkScreen">
+      <field name="closed" type="guint"/>
+      <field name="normal_gcs" type="GdkGC*"/>
+      <field name="exposure_gcs" type="GdkGC*"/>
+      <field name="font_options" type="cairo_font_options_t*"/>
+      <field name="resolution" type="double"/>
+      <property name="font-options" readable="1" type="gpointer" writable="1"/>
+      <property name="resolution" readable="1" type="gdouble" writable="1"/>
+      <signal name="size_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </signal>
+      <signal name="composited_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </signal>
+      <method name="broadcast_client_message" symbol="gdk_screen_broadcast_client_message">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="get_active_window" symbol="gdk_screen_get_active_window">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_default" symbol="gdk_screen_get_default">
+        <return-type type="GdkScreen*"/>
+      </method>
+      <method name="get_default_colormap" symbol="gdk_screen_get_default_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_display" symbol="gdk_screen_get_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_font_options" symbol="gdk_screen_get_font_options">
+        <return-type type="const-cairo_font_options_t*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_height" symbol="gdk_screen_get_height">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_height_mm" symbol="gdk_screen_get_height_mm">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_monitor_at_point" symbol="gdk_screen_get_monitor_at_point">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_monitor_at_window" symbol="gdk_screen_get_monitor_at_window">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_monitor_geometry" symbol="gdk_screen_get_monitor_geometry">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="monitor_num" type="gint"/>
+          <parameter name="dest" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_n_monitors" symbol="gdk_screen_get_n_monitors">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_number" symbol="gdk_screen_get_number">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_resolution" symbol="gdk_screen_get_resolution">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_rgb_colormap" symbol="gdk_screen_get_rgb_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_rgb_visual" symbol="gdk_screen_get_rgb_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_rgba_colormap" symbol="gdk_screen_get_rgba_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_rgba_visual" symbol="gdk_screen_get_rgba_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_root_window" symbol="gdk_screen_get_root_window">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_setting" symbol="gdk_screen_get_setting">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="get_system_colormap" symbol="gdk_screen_get_system_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_system_visual" symbol="gdk_screen_get_system_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_toplevel_windows" symbol="gdk_screen_get_toplevel_windows">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_screen_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="gdk_screen_get_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_width_mm" symbol="gdk_screen_get_width_mm">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_window_stack" symbol="gdk_screen_get_window_stack">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="height" symbol="gdk_screen_height">
+        <return-type type="gint"/>
+      </method>
+      <method name="height_mm" symbol="gdk_screen_height_mm">
+        <return-type type="gint"/>
+      </method>
+      <method name="is_composited" symbol="gdk_screen_is_composited">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="list_visuals" symbol="gdk_screen_list_visuals">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="make_display_name" symbol="gdk_screen_make_display_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="set_default_colormap" symbol="gdk_screen_set_default_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="set_font_options" symbol="gdk_screen_set_font_options">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="options" type="const-cairo_font_options_t*"/>
+        </parameters>
+      </method>
+      <method name="set_resolution" symbol="gdk_screen_set_resolution">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="dpi" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="width" symbol="gdk_screen_width">
+        <return-type type="gint"/>
+      </method>
+      <method name="width_mm" symbol="gdk_screen_width_mm">
+        <return-type type="gint"/>
+      </method>
+    </object>
+    <object get-type="" name="GdkVisual" parent="GObject" type-name="GdkVisual">
+      <field name="type" type="GdkVisualType"/>
+      <field name="depth" type="gint"/>
+      <field name="byte_order" type="GdkByteOrder"/>
+      <field name="colormap_size" type="gint"/>
+      <field name="bits_per_rgb" type="gint"/>
+      <field name="red_mask" type="guint32"/>
+      <field name="red_shift" type="gint"/>
+      <field name="red_prec" type="gint"/>
+      <field name="green_mask" type="guint32"/>
+      <field name="green_shift" type="gint"/>
+      <field name="green_prec" type="gint"/>
+      <field name="blue_mask" type="guint32"/>
+      <field name="blue_shift" type="gint"/>
+      <field name="blue_prec" type="gint"/>
+      <method name="get_best" symbol="gdk_visual_get_best">
+        <return-type type="GdkVisual*"/>
+      </method>
+      <method name="get_best_depth" symbol="gdk_visual_get_best_depth">
+        <return-type type="gint"/>
+      </method>
+      <method name="get_best_type" symbol="gdk_visual_get_best_type">
+        <return-type type="GdkVisualType"/>
+      </method>
+      <method name="get_best_with_both" symbol="gdk_visual_get_best_with_both">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="depth" type="gint"/>
+          <parameter name="visual_type" type="GdkVisualType"/>
+        </parameters>
+      </method>
+      <method name="get_best_with_depth" symbol="gdk_visual_get_best_with_depth">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="depth" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_best_with_type" symbol="gdk_visual_get_best_with_type">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="visual_type" type="GdkVisualType"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gdk_visual_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="visual" type="GdkVisual*"/>
+        </parameters>
+      </method>
+      <method name="get_system" symbol="gdk_visual_get_system">
+        <return-type type="GdkVisual*"/>
+      </method>
+      <method name="get_type" symbol="gdk_visual_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GdkWindow" parent="GdkDrawable" type-name="GdkWindow">
+      <method name="add_filter" symbol="gdk_window_add_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="function" type="GdkFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="at_pointer" symbol="gdk_window_at_pointer">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="win_x" type="gint*"/>
+          <parameter name="win_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="begin_move_drag" symbol="gdk_window_begin_move_drag">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="button" type="gint"/>
+          <parameter name="root_x" type="gint"/>
+          <parameter name="root_y" type="gint"/>
+          <parameter name="timestamp" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="begin_paint_rect" symbol="gdk_window_begin_paint_rect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="begin_paint_region" symbol="gdk_window_begin_paint_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="begin_resize_drag" symbol="gdk_window_begin_resize_drag">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="edge" type="GdkWindowEdge"/>
+          <parameter name="button" type="gint"/>
+          <parameter name="root_x" type="gint"/>
+          <parameter name="root_y" type="gint"/>
+          <parameter name="timestamp" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="clear" symbol="gdk_window_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="clear_area" symbol="gdk_window_clear_area">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="clear_area_e" symbol="gdk_window_clear_area_e">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="configure_finished" symbol="gdk_window_configure_finished">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="constrain_size" symbol="gdk_window_constrain_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="geometry" type="GdkGeometry*"/>
+          <parameter name="flags" type="guint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="new_width" type="gint*"/>
+          <parameter name="new_height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="deiconify" symbol="gdk_window_deiconify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="gdk_window_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="enable_synchronized_configure" symbol="gdk_window_enable_synchronized_configure">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="end_paint" symbol="gdk_window_end_paint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="focus" symbol="gdk_window_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="timestamp" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="foreign_new" symbol="gdk_window_foreign_new">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="foreign_new_for_display" symbol="gdk_window_foreign_new_for_display">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="freeze_updates" symbol="gdk_window_freeze_updates">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="fullscreen" symbol="gdk_window_fullscreen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_children" symbol="gdk_window_get_children">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_decorations" symbol="gdk_window_get_decorations">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="decorations" type="GdkWMDecoration*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_deskrelative_origin" symbol="gdk_window_get_deskrelative_origin">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_events" symbol="gdk_window_get_events">
+        <return-type type="GdkEventMask"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_frame_extents" symbol="gdk_window_get_frame_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="rect" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_geometry" symbol="gdk_window_get_geometry">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+          <parameter name="depth" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_group" symbol="gdk_window_get_group">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_internal_paint_info" symbol="gdk_window_get_internal_paint_info">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="real_drawable" type="GdkDrawable**"/>
+          <parameter name="x_offset" type="gint*"/>
+          <parameter name="y_offset" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_origin" symbol="gdk_window_get_origin">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_parent" symbol="gdk_window_get_parent">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_pointer" symbol="gdk_window_get_pointer">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="mask" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+      <method name="get_position" symbol="gdk_window_get_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_root_origin" symbol="gdk_window_get_root_origin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_state" symbol="gdk_window_get_state">
+        <return-type type="GdkWindowState"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_toplevel" symbol="gdk_window_get_toplevel">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_toplevels" symbol="gdk_window_get_toplevels">
+        <return-type type="GList*"/>
+      </method>
+      <method name="get_type_hint" symbol="gdk_window_get_type_hint">
+        <return-type type="GdkWindowTypeHint"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_update_area" symbol="gdk_window_get_update_area">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_user_data" symbol="gdk_window_get_user_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="data" type="gpointer*"/>
+        </parameters>
+      </method>
+      <method name="get_window_type" symbol="gdk_window_get_window_type">
+        <return-type type="GdkWindowType"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="hide" symbol="gdk_window_hide">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="iconify" symbol="gdk_window_iconify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="input_shape_combine_mask" symbol="gdk_window_input_shape_combine_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="input_shape_combine_region" symbol="gdk_window_input_shape_combine_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="shape_region" type="GdkRegion*"/>
+          <parameter name="offset_x" type="gint"/>
+          <parameter name="offset_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="invalidate_maybe_recurse" symbol="gdk_window_invalidate_maybe_recurse">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="child_func" type="invalidate_maybe_recurseChildFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="invalidate_rect" symbol="gdk_window_invalidate_rect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="rect" type="GdkRectangle*"/>
+          <parameter name="invalidate_children" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="invalidate_region" symbol="gdk_window_invalidate_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="invalidate_children" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="is_viewable" symbol="gdk_window_is_viewable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="is_visible" symbol="gdk_window_is_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="lookup" symbol="gdk_window_lookup">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="lookup_for_display" symbol="gdk_window_lookup_for_display">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="anid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="lower" symbol="gdk_window_lower">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="maximize" symbol="gdk_window_maximize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="merge_child_input_shapes" symbol="gdk_window_merge_child_input_shapes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="merge_child_shapes" symbol="gdk_window_merge_child_shapes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="move" symbol="gdk_window_move">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="move_region" symbol="gdk_window_move_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="dx" type="gint"/>
+          <parameter name="dy" type="gint"/>
+        </parameters>
+      </method>
+      <method name="move_resize" symbol="gdk_window_move_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gdk_window_new">
+        <parameters>
+          <parameter name="parent" type="GdkWindow*"/>
+          <parameter name="attributes" type="GdkWindowAttr*"/>
+          <parameter name="attributes_mask" type="gint"/>
+        </parameters>
+      </constructor>
+      <method name="peek_children" symbol="gdk_window_peek_children">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="process_all_updates" symbol="gdk_window_process_all_updates">
+        <return-type type="void"/>
+      </method>
+      <method name="process_updates" symbol="gdk_window_process_updates">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="update_children" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="raise" symbol="gdk_window_raise">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="register_dnd" symbol="gdk_window_register_dnd">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="remove_filter" symbol="gdk_window_remove_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="function" type="GdkFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="reparent" symbol="gdk_window_reparent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="new_parent" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="resize" symbol="gdk_window_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="scroll" symbol="gdk_window_scroll">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="dx" type="gint"/>
+          <parameter name="dy" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_accept_focus" symbol="gdk_window_set_accept_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="accept_focus" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_back_pixmap" symbol="gdk_window_set_back_pixmap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="parent_relative" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_background" symbol="gdk_window_set_background">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_child_input_shapes" symbol="gdk_window_set_child_input_shapes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="set_child_shapes" symbol="gdk_window_set_child_shapes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="set_cursor" symbol="gdk_window_set_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="cursor" type="GdkCursor*"/>
+        </parameters>
+      </method>
+      <method name="set_debug_updates" symbol="gdk_window_set_debug_updates">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_decorations" symbol="gdk_window_set_decorations">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="decorations" type="GdkWMDecoration"/>
+        </parameters>
+      </method>
+      <method name="set_events" symbol="gdk_window_set_events">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="event_mask" type="GdkEventMask"/>
+        </parameters>
+      </method>
+      <method name="set_focus_on_map" symbol="gdk_window_set_focus_on_map">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="focus_on_map" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_functions" symbol="gdk_window_set_functions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="functions" type="GdkWMFunction"/>
+        </parameters>
+      </method>
+      <method name="set_geometry_hints" symbol="gdk_window_set_geometry_hints">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="geometry" type="GdkGeometry*"/>
+          <parameter name="geom_mask" type="GdkWindowHints"/>
+        </parameters>
+      </method>
+      <method name="set_group" symbol="gdk_window_set_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="leader" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_hints" symbol="gdk_window_set_hints">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="min_width" type="gint"/>
+          <parameter name="min_height" type="gint"/>
+          <parameter name="max_width" type="gint"/>
+          <parameter name="max_height" type="gint"/>
+          <parameter name="flags" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_icon" symbol="gdk_window_set_icon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="icon_window" type="GdkWindow*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_list" symbol="gdk_window_set_icon_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="pixbufs" type="GList*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_name" symbol="gdk_window_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_keep_above" symbol="gdk_window_set_keep_above">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_keep_below" symbol="gdk_window_set_keep_below">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_modal_hint" symbol="gdk_window_set_modal_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="modal" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_override_redirect" symbol="gdk_window_set_override_redirect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="override_redirect" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_role" symbol="gdk_window_set_role">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="role" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_skip_pager_hint" symbol="gdk_window_set_skip_pager_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="skips_pager" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_skip_taskbar_hint" symbol="gdk_window_set_skip_taskbar_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="skips_taskbar" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_static_gravities" symbol="gdk_window_set_static_gravities">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="use_static" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gdk_window_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_transient_for" symbol="gdk_window_set_transient_for">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="parent" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="set_type_hint" symbol="gdk_window_set_type_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="hint" type="GdkWindowTypeHint"/>
+        </parameters>
+      </method>
+      <method name="set_urgency_hint" symbol="gdk_window_set_urgency_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="urgent" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_user_data" symbol="gdk_window_set_user_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="shape_combine_mask" symbol="gdk_window_shape_combine_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="shape_combine_region" symbol="gdk_window_shape_combine_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="shape_region" type="GdkRegion*"/>
+          <parameter name="offset_x" type="gint"/>
+          <parameter name="offset_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="show" symbol="gdk_window_show">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="show_unraised" symbol="gdk_window_show_unraised">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="stick" symbol="gdk_window_stick">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="thaw_updates" symbol="gdk_window_thaw_updates">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="unfullscreen" symbol="gdk_window_unfullscreen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="unmaximize" symbol="gdk_window_unmaximize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="unstick" symbol="gdk_window_unstick">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="withdraw" symbol="gdk_window_withdraw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+    </object>
+    <struct get-type="" name="BRESINFO" type-name="BRESINFO">
+      <field name="minor_axis" readable="1" type="int" writable="1"/>
+      <field name="d" readable="1" type="int" writable="1"/>
+      <field name="m" readable="1" type="int" writable="1"/>
+      <field name="m1" readable="1" type="int" writable="1"/>
+      <field name="incr1" readable="1" type="int" writable="1"/>
+      <field name="incr2" readable="1" type="int" writable="1"/>
+    </struct>
+    <struct get-type="" name="EdgeTable" type-name="EdgeTable">
+      <field name="ymax" readable="1" type="int" writable="1"/>
+      <field name="ymin" readable="1" type="int" writable="1"/>
+      <field name="scanlines" readable="1" type="ScanLineList" writable="1"/>
+    </struct>
+    <struct get-type="" name="EdgeTableEntry" opaque="true" type-name="EdgeTableEntry"/>
+    <object get-type="" name="GdkBitmap" type-name="GdkBitmap">
+      <field name="parent_instance" readable="1" type="GObject" writable="1"/>
+      <method name="create_from_data" symbol="gdk_bitmap_create_from_data">
+        <return-type type="GdkBitmap*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="data" type="const-gchar*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <boxed get-type="" name="GdkColor" type-name="GdkColor">
+      <field name="pixel" readable="1" type="guint32" writable="1"/>
+      <field name="red" readable="1" type="guint16" writable="1"/>
+      <field name="green" readable="1" type="guint16" writable="1"/>
+      <field name="blue" readable="1" type="guint16" writable="1"/>
+      <method deprecated="1" name="alloc" symbol="gdk_color_alloc">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="black" symbol="gdk_color_black">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="change" symbol="gdk_color_change">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="gdk_color_copy">
+        <return-type type="GdkColor*"/>
+        <parameters>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="equal" symbol="gdk_color_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="colora" type="const-GdkColor*"/>
+          <parameter name="colorb" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gdk_color_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_color_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="hash" symbol="gdk_color_hash">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="colora" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="parse" symbol="gdk_color_parse">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="spec" type="const-gchar*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="white" symbol="gdk_color_white">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="GdkCursor" opaque="true" type-name="GdkCursor">
+      <field access="public" name="type" readable="1" type="GdkCursorType" writable="1" writeable="true"/>
+      <field access="public" name="ref_count" type="guint" writeable="true"/>
+      <method name="get_display" symbol="gdk_cursor_get_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="cursor" type="GdkCursor*"/>
+        </parameters>
+      </method>
+      <method name="get_image" symbol="gdk_cursor_get_image">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="cursor" type="GdkCursor*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_cursor_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="gdk_cursor_new">
+        <return-type type="GdkCursor*"/>
+        <parameters>
+          <parameter name="cursor_type" type="GdkCursorType"/>
+        </parameters>
+      </method>
+      <method name="new_for_display" symbol="gdk_cursor_new_for_display">
+        <return-type type="GdkCursor*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="cursor_type" type="GdkCursorType"/>
+        </parameters>
+      </method>
+      <method name="new_from_name" symbol="gdk_cursor_new_from_name">
+        <return-type type="GdkCursor*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="new_from_pixbuf" symbol="gdk_cursor_new_from_pixbuf">
+        <return-type type="GdkCursor*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="new_from_pixmap" symbol="gdk_cursor_new_from_pixmap">
+        <return-type type="GdkCursor*"/>
+        <parameters>
+          <parameter name="source" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkPixmap*"/>
+          <parameter name="fg" type="const-GdkColor*"/>
+          <parameter name="bg" type="const-GdkColor*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="gdk_cursor_ref">
+        <return-type type="GdkCursor*"/>
+        <parameters>
+          <parameter name="cursor" type="GdkCursor*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gdk_cursor_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cursor" type="GdkCursor*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GdkDeviceAxis" type-name="GdkDeviceAxis">
+      <field name="use" readable="1" type="GdkAxisUse" writable="1"/>
+      <field name="min" readable="1" type="gdouble" writable="1"/>
+      <field name="max" readable="1" type="gdouble" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkDeviceKey" type-name="GdkDeviceKey">
+      <field name="keyval" readable="1" type="guint" writable="1"/>
+      <field name="modifiers" readable="1" type="GdkModifierType" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkDisplayPointerHooks" type-name="GdkDisplayPointerHooks"/>
+    <struct get-type="" name="GdkEventAny" type-name="GdkEventAny">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventButton" type-name="GdkEventButton">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="x" readable="1" type="gdouble" writable="1"/>
+      <field name="y" readable="1" type="gdouble" writable="1"/>
+      <field name="axes" readable="1" type="gdouble*" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+      <field name="button" readable="1" type="guint" writable="1"/>
+      <field name="device" readable="1" type="GdkDevice*" writable="1"/>
+      <field name="x_root" readable="1" type="gdouble" writable="1"/>
+      <field name="y_root" readable="1" type="gdouble" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventClient" type-name="GdkEventClient">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="message_type" readable="1" type="GdkAtom" writable="1"/>
+      <field name="data_format" readable="1" type="gushort" writable="1"/>
+      <field name="b" readable="1" type="char" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventConfigure" type-name="GdkEventConfigure">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventCrossing" type-name="GdkEventCrossing">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="subwindow" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="x" readable="1" type="gdouble" writable="1"/>
+      <field name="y" readable="1" type="gdouble" writable="1"/>
+      <field name="x_root" readable="1" type="gdouble" writable="1"/>
+      <field name="y_root" readable="1" type="gdouble" writable="1"/>
+      <field name="mode" readable="1" type="GdkCrossingMode" writable="1"/>
+      <field name="detail" readable="1" type="GdkNotifyType" writable="1"/>
+      <field name="focus" readable="1" type="gboolean" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventDND" type-name="GdkEventDND">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="context" readable="1" type="GdkDragContext*" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="x_root" readable="1" type="gshort" writable="1"/>
+      <field name="y_root" readable="1" type="gshort" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventExpose" type-name="GdkEventExpose">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="area" readable="1" type="GdkRectangle" writable="1"/>
+      <field name="region" readable="1" type="GdkRegion*" writable="1"/>
+      <field name="count" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventFocus" type-name="GdkEventFocus">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="in" readable="1" type="gint16" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventGrabBroken" type-name="GdkEventGrabBroken">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="keyboard" readable="1" type="gboolean" writable="1"/>
+      <field name="implicit" readable="1" type="gboolean" writable="1"/>
+      <field name="grab_window" readable="1" type="GdkWindow*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventKey" type-name="GdkEventKey">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+      <field name="keyval" readable="1" type="guint" writable="1"/>
+      <field name="length" readable="1" type="gint" writable="1"/>
+      <field name="string" readable="1" type="gchar*" writable="1"/>
+      <field name="hardware_keycode" readable="1" type="guint16" writable="1"/>
+      <field name="group" readable="1" type="guint8" writable="1"/>
+      <field name="is_modifier" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventMotion" type-name="GdkEventMotion">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="x" readable="1" type="gdouble" writable="1"/>
+      <field name="y" readable="1" type="gdouble" writable="1"/>
+      <field name="axes" readable="1" type="gdouble*" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+      <field name="is_hint" readable="1" type="gint16" writable="1"/>
+      <field name="device" readable="1" type="GdkDevice*" writable="1"/>
+      <field name="x_root" readable="1" type="gdouble" writable="1"/>
+      <field name="y_root" readable="1" type="gdouble" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventNoExpose" type-name="GdkEventNoExpose">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventOwnerChange" type-name="GdkEventOwnerChange">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="owner" readable="1" type="GdkNativeWindow" writable="1"/>
+      <field name="reason" readable="1" type="GdkOwnerChange" writable="1"/>
+      <field name="selection" readable="1" type="GdkAtom" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="selection_time" readable="1" type="guint32" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventProperty" type-name="GdkEventProperty">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="atom" readable="1" type="GdkAtom" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventProximity" type-name="GdkEventProximity">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="device" readable="1" type="GdkDevice*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventScroll" type-name="GdkEventScroll">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="x" readable="1" type="gdouble" writable="1"/>
+      <field name="y" readable="1" type="gdouble" writable="1"/>
+      <field name="state" readable="1" type="guint" writable="1"/>
+      <field name="direction" readable="1" type="GdkScrollDirection" writable="1"/>
+      <field name="device" readable="1" type="GdkDevice*" writable="1"/>
+      <field name="x_root" readable="1" type="gdouble" writable="1"/>
+      <field name="y_root" readable="1" type="gdouble" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventSelection" type-name="GdkEventSelection">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="selection" readable="1" type="GdkAtom" writable="1"/>
+      <field name="target" readable="1" type="GdkAtom" writable="1"/>
+      <field name="property" readable="1" type="GdkAtom" writable="1"/>
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="requestor" readable="1" type="GdkNativeWindow" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventSetting" type-name="GdkEventSetting">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="action" readable="1" type="GdkSettingAction" writable="1"/>
+      <field name="name" readable="1" type="char*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventVisibility" type-name="GdkEventVisibility">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="state" readable="1" type="GdkVisibilityState" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkEventWindowState" type-name="GdkEventWindowState">
+      <field name="type" readable="1" type="GdkEventType" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="send_event" readable="1" type="gint8" writable="1"/>
+      <field name="changed_mask" readable="1" type="GdkWindowState" writable="1"/>
+      <field name="new_window_state" readable="1" type="GdkWindowState" writable="1"/>
+    </struct>
+    <boxed deprecated="1" get-type="" name="GdkFont" opaque="true" type-name="GdkFont">
+      <field access="public" name="type" readable="1" type="GdkFontType" writable="1" writeable="true"/>
+      <field access="public" name="ascent" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="descent" readable="1" type="gint" writable="1" writeable="true"/>
+      <method deprecated="1" name="equal" symbol="gdk_font_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="fonta" type="const-GdkFont*"/>
+          <parameter name="fontb" type="const-GdkFont*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="from_description" symbol="gdk_font_from_description">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="font_desc" type="PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="from_description_for_display" symbol="gdk_font_from_description_for_display">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="font_desc" type="PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_display" symbol="gdk_font_get_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_type" symbol="gdk_font_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method deprecated="1" name="id" symbol="gdk_font_id">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="const-GdkFont*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="load" symbol="gdk_font_load">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="font_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="load_for_display" symbol="gdk_font_load_for_display">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="font_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="ref" symbol="gdk_font_ref">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gdk_font_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GdkGCValues" type-name="GdkGCValues">
+      <field name="foreground" readable="1" type="GdkColor" writable="1"/>
+      <field name="background" readable="1" type="GdkColor" writable="1"/>
+      <field name="font" readable="1" type="GdkFont*" writable="1"/>
+      <field name="function" readable="1" type="GdkFunction" writable="1"/>
+      <field name="fill" readable="1" type="GdkFill" writable="1"/>
+      <field name="tile" readable="1" type="GdkPixmap*" writable="1"/>
+      <field name="stipple" readable="1" type="GdkPixmap*" writable="1"/>
+      <field name="clip_mask" readable="1" type="GdkPixmap*" writable="1"/>
+      <field name="subwindow_mode" readable="1" type="GdkSubwindowMode" writable="1"/>
+      <field name="ts_x_origin" readable="1" type="gint" writable="1"/>
+      <field name="ts_y_origin" readable="1" type="gint" writable="1"/>
+      <field name="clip_x_origin" readable="1" type="gint" writable="1"/>
+      <field name="clip_y_origin" readable="1" type="gint" writable="1"/>
+      <field name="graphics_exposures" readable="1" type="gint" writable="1"/>
+      <field name="line_width" readable="1" type="gint" writable="1"/>
+      <field name="line_style" readable="1" type="GdkLineStyle" writable="1"/>
+      <field name="cap_style" readable="1" type="GdkCapStyle" writable="1"/>
+      <field name="join_style" readable="1" type="GdkJoinStyle" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkGeometry" type-name="GdkGeometry">
+      <field name="min_width" readable="1" type="gint" writable="1"/>
+      <field name="min_height" readable="1" type="gint" writable="1"/>
+      <field name="max_width" readable="1" type="gint" writable="1"/>
+      <field name="max_height" readable="1" type="gint" writable="1"/>
+      <field name="base_width" readable="1" type="gint" writable="1"/>
+      <field name="base_height" readable="1" type="gint" writable="1"/>
+      <field name="width_inc" readable="1" type="gint" writable="1"/>
+      <field name="height_inc" readable="1" type="gint" writable="1"/>
+      <field name="min_aspect" readable="1" type="gdouble" writable="1"/>
+      <field name="max_aspect" readable="1" type="gdouble" writable="1"/>
+      <field name="win_gravity" readable="1" type="GdkGravity" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkKeymapKey" type-name="GdkKeymapKey">
+      <field name="keycode" readable="1" type="guint" writable="1"/>
+      <field name="group" readable="1" type="gint" writable="1"/>
+      <field name="level" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkPangoAttrEmbossed" opaque="true" type-name="GdkPangoAttrEmbossed">
+      <field access="public" name="attr" readable="1" type="PangoAttribute" writable="1" writeable="true"/>
+      <field access="public" name="embossed" readable="1" type="gboolean" writable="1" writeable="true"/>
+      <method name="new" symbol="gdk_pango_attr_embossed_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="embossed" type="gboolean"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GdkPangoAttrStipple" opaque="true" type-name="GdkPangoAttrStipple">
+      <field access="public" name="attr" readable="1" type="PangoAttribute" writable="1" writeable="true"/>
+      <field access="public" name="stipple" readable="1" type="GdkBitmap*" writable="1" writeable="true"/>
+      <method name="new" symbol="gdk_pango_attr_stipple_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="stipple" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GdkPixbufFormat" opaque="true" type-name="GdkPixbufFormat">
+      <method name="get_description" symbol="gdk_pixbuf_format_get_description">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="get_extensions" symbol="gdk_pixbuf_format_get_extensions">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="get_license" symbol="gdk_pixbuf_format_get_license">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="get_mime_types" symbol="gdk_pixbuf_format_get_mime_types">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gdk_pixbuf_format_get_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="is_disabled" symbol="gdk_pixbuf_format_is_disabled">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="is_scalable" symbol="gdk_pixbuf_format_is_scalable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="is_writable" symbol="gdk_pixbuf_format_is_writable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+        </parameters>
+      </method>
+      <method name="set_disabled" symbol="gdk_pixbuf_format_set_disabled">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="format" type="GdkPixbufFormat*"/>
+          <parameter name="disabled" type="gboolean"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GdkPixbufFrame" type-name="GdkPixbufFrame">
+      <field name="pixbuf" readable="1" type="GdkPixbuf*" writable="1"/>
+      <field name="x_offset" readable="1" type="int" writable="1"/>
+      <field name="y_offset" readable="1" type="int" writable="1"/>
+      <field name="delay_time" readable="1" type="int" writable="1"/>
+      <field name="elapsed" readable="1" type="int" writable="1"/>
+      <field name="action" readable="1" type="GdkPixbufFrameAction" writable="1"/>
+      <field name="need_recomposite" readable="1" type="gboolean" writable="1"/>
+      <field name="bg_transparent" readable="1" type="gboolean" writable="1"/>
+      <field name="composited" readable="1" type="GdkPixbuf*" writable="1"/>
+      <field name="revert" readable="1" type="GdkPixbuf*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkPixdata" type-name="GdkPixdata">
+      <field name="magic" readable="1" type="guint32" writable="1"/>
+      <field name="length" readable="1" type="gint32" writable="1"/>
+      <field name="pixdata_type" readable="1" type="guint32" writable="1"/>
+      <field name="rowstride" readable="1" type="guint32" writable="1"/>
+      <field name="width" readable="1" type="guint32" writable="1"/>
+      <field name="height" readable="1" type="guint32" writable="1"/>
+      <field name="pixel_data" readable="1" type="guint8*" writable="1"/>
+      <method name="deserialize" symbol="gdk_pixdata_deserialize">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pixdata" type="GdkPixdata*"/>
+          <parameter name="stream_length" type="guint"/>
+          <parameter name="stream" type="const-guint8*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="from_pixbuf" symbol="gdk_pixdata_from_pixbuf">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="pixdata" type="GdkPixdata*"/>
+          <parameter name="pixbuf" type="const-GdkPixbuf*"/>
+          <parameter name="use_rle" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="serialize" symbol="gdk_pixdata_serialize">
+        <return-type type="guint8*"/>
+        <parameters>
+          <parameter name="pixdata" type="const-GdkPixdata*"/>
+          <parameter name="stream_length_p" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="to_csource" symbol="gdk_pixdata_to_csource">
+        <return-type type="GString*"/>
+        <parameters>
+          <parameter name="pixdata" type="GdkPixdata*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="dump_type" type="GdkPixdataDumpType"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GdkPixmapObject" type-name="GdkPixmapObject">
+      <field name="parent_instance" readable="1" type="GdkDrawable" writable="1"/>
+      <field name="impl" readable="1" type="GdkDrawable*" writable="1"/>
+      <field name="depth" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkPoint" type-name="GdkPoint">
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkPointerHooks" type-name="GdkPointerHooks"/>
+    <boxed get-type="" name="GdkRectangle" type-name="GdkRectangle">
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+      <method name="get_type" symbol="gdk_rectangle_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="intersect" symbol="gdk_rectangle_intersect">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="src1" type="GdkRectangle*"/>
+          <parameter name="src2" type="GdkRectangle*"/>
+          <parameter name="dest" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="union" symbol="gdk_rectangle_union">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src1" type="GdkRectangle*"/>
+          <parameter name="src2" type="GdkRectangle*"/>
+          <parameter name="dest" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GdkRegion" opaque="true" type-name="GdkRegion">
+      <field access="public" name="size" readable="1" type="long" writable="1" writeable="true"/>
+      <field access="public" name="numRects" readable="1" type="long" writable="1" writeable="true"/>
+      <field access="public" name="rects" readable="1" type="GdkRegionBox*" writable="1" writeable="true"/>
+      <field access="public" name="extents" readable="1" type="GdkRegionBox" writable="1" writeable="true"/>
+      <method name="copy" symbol="gdk_region_copy">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="gdk_region_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="empty" symbol="gdk_region_empty">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="equal" symbol="gdk_region_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="region1" type="GdkRegion*"/>
+          <parameter name="region2" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="get_clipbox" symbol="gdk_region_get_clipbox">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_rectangles" symbol="gdk_region_get_rectangles">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="rectangles" type="GdkRectangle**"/>
+          <parameter name="n_rectangles" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="intersect" symbol="gdk_region_intersect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source1" type="GdkRegion*"/>
+          <parameter name="source2" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gdk_region_new">
+        <return-type type="GdkRegion*"/>
+      </method>
+      <method name="offset" symbol="gdk_region_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="dx" type="gint"/>
+          <parameter name="dy" type="gint"/>
+        </parameters>
+      </method>
+      <method name="point_in" symbol="gdk_region_point_in">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+        </parameters>
+      </method>
+      <method name="polygon" symbol="gdk_region_polygon">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+          <parameter name="fill_rule" type="GdkFillRule"/>
+        </parameters>
+      </method>
+      <method name="rect_in" symbol="gdk_region_rect_in">
+        <return-type type="GdkOverlapType"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="rectangle" symbol="gdk_region_rectangle">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="shrink" symbol="gdk_region_shrink">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="dx" type="gint"/>
+          <parameter name="dy" type="gint"/>
+        </parameters>
+      </method>
+      <method name="spans_intersect_foreach" symbol="gdk_region_spans_intersect_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="spans" type="GdkSpan*"/>
+          <parameter name="n_spans" type="int"/>
+          <parameter name="sorted" type="gboolean"/>
+          <parameter name="function" type="GdkSpanFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="subtract" symbol="gdk_region_subtract">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source1" type="GdkRegion*"/>
+          <parameter name="source2" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="union" symbol="gdk_region_union">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source1" type="GdkRegion*"/>
+          <parameter name="source2" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="union_with_rect" symbol="gdk_region_union_with_rect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="region" type="GdkRegion*"/>
+          <parameter name="rect" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="xor" symbol="gdk_region_xor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source1" type="GdkRegion*"/>
+          <parameter name="source2" type="GdkRegion*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GdkRegionBox" type-name="GdkRegionBox">
+      <field name="x1" readable="1" type="gint" writable="1"/>
+      <field name="y1" readable="1" type="gint" writable="1"/>
+      <field name="x2" readable="1" type="gint" writable="1"/>
+      <field name="y2" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkRgbCmap" opaque="true" type-name="GdkRgbCmap">
+      <field access="public" name="colors" readable="1" type="guint32" writable="1" writeable="true"/>
+      <field access="public" name="n_colors" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="info_list" type="GSList*" writeable="true"/>
+      <method name="free" symbol="gdk_rgb_cmap_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cmap" type="GdkRgbCmap*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gdk_rgb_cmap_new">
+        <return-type type="GdkRgbCmap*"/>
+        <parameters>
+          <parameter name="colors" type="guint32*"/>
+          <parameter name="n_colors" type="gint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GdkSegment" type-name="GdkSegment">
+      <field name="x1" readable="1" type="gint" writable="1"/>
+      <field name="y1" readable="1" type="gint" writable="1"/>
+      <field name="x2" readable="1" type="gint" writable="1"/>
+      <field name="y2" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkSpan" type-name="GdkSpan">
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkTimeCoord" type-name="GdkTimeCoord">
+      <field name="time" readable="1" type="guint32" writable="1"/>
+      <field name="axes" readable="1" type="gdouble" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkTrapezoid" type-name="GdkTrapezoid">
+      <field name="y1" readable="1" type="double" writable="1"/>
+      <field name="x11" readable="1" type="double" writable="1"/>
+      <field name="x21" readable="1" type="double" writable="1"/>
+      <field name="y2" readable="1" type="double" writable="1"/>
+      <field name="x12" readable="1" type="double" writable="1"/>
+      <field name="x22" readable="1" type="double" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkWindowAttr" type-name="GdkWindowAttr">
+      <field name="title" readable="1" type="gchar*" writable="1"/>
+      <field name="event_mask" readable="1" type="gint" writable="1"/>
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+      <field name="wclass" readable="1" type="GdkWindowClass" writable="1"/>
+      <field name="visual" readable="1" type="GdkVisual*" writable="1"/>
+      <field name="colormap" readable="1" type="GdkColormap*" writable="1"/>
+      <field name="window_type" readable="1" type="GdkWindowType" writable="1"/>
+      <field name="cursor" readable="1" type="GdkCursor*" writable="1"/>
+      <field name="wmclass_name" readable="1" type="gchar*" writable="1"/>
+      <field name="wmclass_class" readable="1" type="gchar*" writable="1"/>
+      <field name="override_redirect" readable="1" type="gboolean" writable="1"/>
+    </struct>
+    <struct get-type="" name="GdkWindowObject" type-name="GdkWindowObject">
+      <field name="parent_instance" readable="1" type="GdkDrawable" writable="1"/>
+      <field name="impl" readable="1" type="GdkDrawable*" writable="1"/>
+      <field name="parent" readable="1" type="GdkWindowObject*" writable="1"/>
+      <field name="user_data" readable="1" type="gpointer" writable="1"/>
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="extension_events" readable="1" type="gint" writable="1"/>
+      <field name="filters" readable="1" type="GList*" writable="1"/>
+      <field name="children" readable="1" type="GList*" writable="1"/>
+      <field name="bg_color" readable="1" type="GdkColor" writable="1"/>
+      <field name="bg_pixmap" readable="1" type="GdkPixmap*" writable="1"/>
+      <field name="paint_stack" readable="1" type="GSList*" writable="1"/>
+      <field name="update_area" readable="1" type="GdkRegion*" writable="1"/>
+      <field name="update_freeze_count" readable="1" type="guint" writable="1"/>
+      <field name="window_type" readable="1" type="guint8" writable="1"/>
+      <field name="depth" readable="1" type="guint8" writable="1"/>
+      <field name="resize_count" readable="1" type="guint8" writable="1"/>
+      <field name="state" readable="1" type="GdkWindowState" writable="1"/>
+      <field name="guffaw_gravity" readable="1" type="guint" writable="1"/>
+      <field name="input_only" readable="1" type="guint" writable="1"/>
+      <field name="modal_hint" readable="1" type="guint" writable="1"/>
+      <field name="destroyed" readable="1" type="guint" writable="1"/>
+      <field name="accept_focus" readable="1" type="guint" writable="1"/>
+      <field name="focus_on_map" readable="1" type="guint" writable="1"/>
+      <field name="shaped" readable="1" type="guint" writable="1"/>
+      <field name="event_mask" readable="1" type="GdkEventMask" writable="1"/>
+      <method name="get_type" symbol="gdk_window_object_get_type">
+        <return-type type="GType"/>
+      </method>
+    </struct>
+    <struct get-type="" name="POINTBLOCK" opaque="true" type-name="POINTBLOCK"/>
+    <struct get-type="" name="ScanLineList" opaque="true" type-name="ScanLineList"/>
+    <struct get-type="" name="ScanLineListBlock" opaque="true" type-name="ScanLineListBlock"/>
+    <struct name="GdkAtom" opaque="true" type-name="GdkAtom">
+      <method name="intern" symbol="gdk_atom_intern">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="atom_name" type="const-gchar*"/>
+          <parameter name="only_if_exists" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="intern_static_string" symbol="gdk_atom_intern_static_string">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="atom_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="name" symbol="gdk_atom_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="atom" type="GdkAtom"/>
+        </parameters>
+      </method>
+    </struct>
+    <callback name="invalidate_maybe_recurseChildFunc" type-name="invalidate_maybe_recurseChildFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="arg1" type="GdkWindow*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <struct cname="GdkGlobal" name="Global">
+      <method name="_add_client_message_filter" symbol="gdk_add_client_message_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="message_type" type="GdkAtom"/>
+          <parameter name="func" type="GdkFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="_add_option_entries_libgtk_only" symbol="gdk_add_option_entries_libgtk_only">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="group" type="GOptionGroup*"/>
+        </parameters>
+      </method>
+      <method name="_devices_list" symbol="gdk_devices_list">
+        <return-type type="GList*"/>
+      </method>
+      <method name="_events_pending" symbol="gdk_events_pending">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="_free_compound_text" symbol="gdk_free_compound_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ctext" type="guchar*"/>
+        </parameters>
+      </method>
+      <method name="_free_text_list" symbol="gdk_free_text_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="_get_default_root_window" symbol="gdk_get_default_root_window">
+        <return-type type="GdkWindow*"/>
+      </method>
+      <method name="_get_display" symbol="gdk_get_display">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="_get_display_arg_name" symbol="gdk_get_display_arg_name">
+        <return-type type="const-gchar*"/>
+      </method>
+      <method name="_get_program_class" symbol="gdk_get_program_class">
+        <return-type type="const-char*"/>
+      </method>
+      <method name="_get_show_events" symbol="gdk_get_show_events">
+        <return-type type="gboolean"/>
+      </method>
+      <method deprecated="1" name="_get_use_xshm" symbol="gdk_get_use_xshm">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="_init_check" symbol="gdk_init_check">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="argc" type="gint*"/>
+          <parameter name="argv" type="gchar***"/>
+        </parameters>
+      </method>
+      <method name="_list_visuals" symbol="gdk_list_visuals">
+        <return-type type="GList*"/>
+      </method>
+      <method name="_notify_startup_complete" symbol="gdk_notify_startup_complete">
+        <return-type type="void"/>
+      </method>
+      <method name="_parse_args" symbol="gdk_parse_args">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="argc" type="gint*"/>
+          <parameter name="argv" type="gchar***"/>
+        </parameters>
+      </method>
+      <method name="_pre_parse_libgtk_only" symbol="gdk_pre_parse_libgtk_only">
+        <return-type type="void"/>
+      </method>
+      <method name="_set_double_click_time" symbol="gdk_set_double_click_time">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="msec" type="guint"/>
+        </parameters>
+      </method>
+      <method name="_set_locale" symbol="gdk_set_locale">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="_set_pointer_hooks" symbol="gdk_set_pointer_hooks">
+        <return-type type="GdkPointerHooks*"/>
+        <parameters>
+          <parameter name="new_hooks" type="const-GdkPointerHooks*"/>
+        </parameters>
+      </method>
+      <method name="_set_program_class" symbol="gdk_set_program_class">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="program_class" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="_set_show_events" symbol="gdk_set_show_events">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="show_events" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_set_sm_client_id" symbol="gdk_set_sm_client_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sm_client_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_set_use_xshm" symbol="gdk_set_use_xshm">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="use_xshm" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_setting_get" symbol="gdk_setting_get">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_string_extents" symbol="gdk_string_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="string" type="const-gchar*"/>
+          <parameter name="lbearing" type="gint*"/>
+          <parameter name="rbearing" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="ascent" type="gint*"/>
+          <parameter name="descent" type="gint*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_string_height" symbol="gdk_string_height">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_string_measure" symbol="gdk_string_measure">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="_string_to_compound_text" symbol="gdk_string_to_compound_text">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="str" type="const-gchar*"/>
+          <parameter name="encoding" type="GdkAtom*"/>
+          <parameter name="format" type="gint*"/>
+          <parameter name="ctext" type="guchar**"/>
+          <parameter name="length" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="_string_to_compound_text_for_display" symbol="gdk_string_to_compound_text_for_display">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="str" type="const-gchar*"/>
+          <parameter name="encoding" type="GdkAtom*"/>
+          <parameter name="format" type="gint*"/>
+          <parameter name="ctext" type="guchar**"/>
+          <parameter name="length" type="gint*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_string_width" symbol="gdk_string_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="_unicode_to_keyval" symbol="gdk_unicode_to_keyval">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="wc" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkCairo">
+      <method name="create" symbol="gdk_cairo_create">
+        <return-type type="cairo_t*"/>
+        <parameters>
+          <parameter name="drawable" type="GdkDrawable*"/>
+        </parameters>
+      </method>
+      <method name="rectangle" symbol="gdk_cairo_rectangle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cr" type="cairo_t*"/>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="region" symbol="gdk_cairo_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cr" type="cairo_t*"/>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="set_source_color" symbol="gdk_cairo_set_source_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cr" type="cairo_t*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_source_pixbuf" symbol="gdk_cairo_set_source_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cr" type="cairo_t*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="pixbuf_x" type="double"/>
+          <parameter name="pixbuf_y" type="double"/>
+        </parameters>
+      </method>
+      <method name="set_source_pixmap" symbol="gdk_cairo_set_source_pixmap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cr" type="cairo_t*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="pixmap_x" type="double"/>
+          <parameter name="pixmap_y" type="double"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkChar">
+      <method deprecated="1" name="height" symbol="gdk_char_height">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="character" type="gchar"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="measure" symbol="gdk_char_measure">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="character" type="gchar"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="width" symbol="gdk_char_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="character" type="gchar"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="width_wc" symbol="gdk_char_width_wc">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="character" type="GdkWChar"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkColors">
+      <method deprecated="1" name="alloc" symbol="gdk_colors_alloc">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="contiguous" type="gboolean"/>
+          <parameter name="planes" type="gulong*"/>
+          <parameter name="nplanes" type="gint"/>
+          <parameter name="pixels" type="gulong*"/>
+          <parameter name="npixels" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="free" symbol="gdk_colors_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="pixels" type="gulong*"/>
+          <parameter name="npixels" type="gint"/>
+          <parameter name="planes" type="gulong"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="store" symbol="gdk_colors_store">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="colors" type="GdkColor*"/>
+          <parameter name="ncolors" type="gint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkDrag">
+      <method name="abort" symbol="gdk_drag_abort">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="begin" symbol="gdk_drag_begin">
+        <return-type type="GdkDragContext*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="targets" type="GList*"/>
+        </parameters>
+      </method>
+      <method name="drop" symbol="gdk_drag_drop">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="drop_succeeded" symbol="gdk_drag_drop_succeeded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </method>
+      <method name="find_window" symbol="gdk_drag_find_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="drag_window" type="GdkWindow*"/>
+          <parameter name="x_root" type="gint"/>
+          <parameter name="y_root" type="gint"/>
+          <parameter name="dest_window" type="GdkWindow**"/>
+          <parameter name="protocol" type="GdkDragProtocol*"/>
+        </parameters>
+      </method>
+      <method name="find_window_for_screen" symbol="gdk_drag_find_window_for_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="drag_window" type="GdkWindow*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="x_root" type="gint"/>
+          <parameter name="y_root" type="gint"/>
+          <parameter name="dest_window" type="GdkWindow**"/>
+          <parameter name="protocol" type="GdkDragProtocol*"/>
+        </parameters>
+      </method>
+      <method name="get_protocol" symbol="gdk_drag_get_protocol">
+        <return-type type="guint32"/>
+        <parameters>
+          <parameter name="xid" type="guint32"/>
+          <parameter name="protocol" type="GdkDragProtocol*"/>
+        </parameters>
+      </method>
+      <method name="get_protocol_for_display" symbol="gdk_drag_get_protocol_for_display">
+        <return-type type="guint32"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="xid" type="guint32"/>
+          <parameter name="protocol" type="GdkDragProtocol*"/>
+        </parameters>
+      </method>
+      <method name="get_selection" symbol="gdk_drag_get_selection">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </method>
+      <method name="motion" symbol="gdk_drag_motion">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="dest_window" type="GdkWindow*"/>
+          <parameter name="protocol" type="GdkDragProtocol"/>
+          <parameter name="x_root" type="gint"/>
+          <parameter name="y_root" type="gint"/>
+          <parameter name="suggested_action" type="GdkDragAction"/>
+          <parameter name="possible_actions" type="GdkDragAction"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="status" symbol="gdk_drag_status">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="action" type="GdkDragAction"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkDrop">
+      <method name="finish" symbol="gdk_drop_finish">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="success" type="gboolean"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="reply" symbol="gdk_drop_reply">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="ok" type="gboolean"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkError">
+      <method name="trap_pop" symbol="gdk_error_trap_pop">
+        <return-type type="gint"/>
+      </method>
+      <method name="trap_push" symbol="gdk_error_trap_push">
+        <return-type type="void"/>
+      </method>
+    </struct>
+    <struct name="GdkEvent">
+      <method name="copy" symbol="gdk_event_copy">
+        <return-type type="GdkEvent*"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gdk_event_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="gdk_event_get">
+        <return-type type="GdkEvent*"/>
+      </method>
+      <method name="get_axis" symbol="gdk_event_get_axis">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="axis_use" type="GdkAxisUse"/>
+          <parameter name="value" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_coords" symbol="gdk_event_get_coords">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="x_win" type="gdouble*"/>
+          <parameter name="y_win" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_graphics_expose" symbol="gdk_event_get_graphics_expose">
+        <return-type type="GdkEvent*"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_root_coords" symbol="gdk_event_get_root_coords">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="x_root" type="gdouble*"/>
+          <parameter name="y_root" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gdk_event_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="get_state" symbol="gdk_event_get_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="state" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+      <method name="get_time" symbol="gdk_event_get_time">
+        <return-type type="guint32"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gdk_event_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="handler_set" symbol="gdk_event_handler_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="func" type="GdkEventFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="notify" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gdk_event_new">
+        <return-type type="GdkEvent*"/>
+        <parameters>
+          <parameter name="type" type="GdkEventType"/>
+        </parameters>
+      </method>
+      <method name="peek" symbol="gdk_event_peek">
+        <return-type type="GdkEvent*"/>
+      </method>
+      <method name="put" symbol="gdk_event_put">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="send_client_message" symbol="gdk_event_send_client_message">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="winid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="send_client_message_for_display" symbol="gdk_event_send_client_message_for_display">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="winid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="send_clientmessage_toall" symbol="gdk_event_send_clientmessage_toall">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="set_screen" symbol="gdk_event_set_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkFontset">
+      <method deprecated="1" name="load" symbol="gdk_fontset_load">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="fontset_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="load_for_display" symbol="gdk_fontset_load_for_display">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="fontset_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkInput">
+      <method deprecated="1" name="add" symbol="gdk_input_add">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="source" type="gint"/>
+          <parameter name="condition" type="GdkInputCondition"/>
+          <parameter name="function" type="GdkInputFunction"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="add_full" symbol="gdk_input_add_full">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="source" type="gint"/>
+          <parameter name="condition" type="GdkInputCondition"/>
+          <parameter name="function" type="GdkInputFunction"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GdkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove" symbol="gdk_input_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tag" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_extension_events" symbol="gdk_input_set_extension_events">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="mask" type="gint"/>
+          <parameter name="mode" type="GdkExtensionMode"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkKeyboard">
+      <method name="grab" symbol="gdk_keyboard_grab">
+        <return-type type="GdkGrabStatus"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="owner_events" type="gboolean"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="grab_info_libgtk_only" symbol="gdk_keyboard_grab_info_libgtk_only">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="grab_window" type="GdkWindow**"/>
+          <parameter name="owner_events" type="gboolean*"/>
+        </parameters>
+      </method>
+      <method name="ungrab" symbol="gdk_keyboard_ungrab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkKeyval">
+      <method name="convert_case" symbol="gdk_keyval_convert_case">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="symbol" type="guint"/>
+          <parameter name="lower" type="guint*"/>
+          <parameter name="upper" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="from_name" symbol="gdk_keyval_from_name">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="keyval_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="is_lower" symbol="gdk_keyval_is_lower">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+        </parameters>
+      </method>
+      <method name="is_upper" symbol="gdk_keyval_is_upper">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+        </parameters>
+      </method>
+      <method name="name" symbol="gdk_keyval_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+        </parameters>
+      </method>
+      <method name="to_lower" symbol="gdk_keyval_to_lower">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+        </parameters>
+      </method>
+      <method name="to_unicode" symbol="gdk_keyval_to_unicode">
+        <return-type type="guint32"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+        </parameters>
+      </method>
+      <method name="to_upper" symbol="gdk_keyval_to_upper">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkPango">
+      <method name="context_get" symbol="gdk_pango_context_get">
+        <return-type type="PangoContext*"/>
+      </method>
+      <method name="context_get_for_screen" symbol="gdk_pango_context_get_for_screen">
+        <return-type type="PangoContext*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="context_set_colormap" symbol="gdk_pango_context_set_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="layout_get_clip_region" symbol="gdk_pango_layout_get_clip_region">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="x_origin" type="gint"/>
+          <parameter name="y_origin" type="gint"/>
+          <parameter name="index_ranges" type="gint*"/>
+          <parameter name="n_ranges" type="gint"/>
+        </parameters>
+      </method>
+      <method name="layout_line_get_clip_region" symbol="gdk_pango_layout_line_get_clip_region">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="x_origin" type="gint"/>
+          <parameter name="y_origin" type="gint"/>
+          <parameter name="index_ranges" type="gint*"/>
+          <parameter name="n_ranges" type="gint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkPointer">
+      <method name="grab" symbol="gdk_pointer_grab">
+        <return-type type="GdkGrabStatus"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="owner_events" type="gboolean"/>
+          <parameter name="event_mask" type="GdkEventMask"/>
+          <parameter name="confine_to" type="GdkWindow*"/>
+          <parameter name="cursor" type="GdkCursor*"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="grab_info_libgtk_only" symbol="gdk_pointer_grab_info_libgtk_only">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="grab_window" type="GdkWindow**"/>
+          <parameter name="owner_events" type="gboolean*"/>
+        </parameters>
+      </method>
+      <method name="is_grabbed" symbol="gdk_pointer_is_grabbed">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="ungrab" symbol="gdk_pointer_ungrab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkProperty">
+      <method name="change" symbol="gdk_property_change">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="property" type="GdkAtom"/>
+          <parameter name="type" type="GdkAtom"/>
+          <parameter name="format" type="gint"/>
+          <parameter name="mode" type="GdkPropMode"/>
+          <parameter name="data" type="const-guchar*"/>
+          <parameter name="nelements" type="gint"/>
+        </parameters>
+      </method>
+      <method name="delete" symbol="gdk_property_delete">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="property" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="gdk_property_get">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="property" type="GdkAtom"/>
+          <parameter name="type" type="GdkAtom"/>
+          <parameter name="offset" type="gulong"/>
+          <parameter name="length" type="gulong"/>
+          <parameter name="pdelete" type="gint"/>
+          <parameter name="actual_property_type" type="GdkAtom*"/>
+          <parameter name="actual_format" type="gint*"/>
+          <parameter name="actual_length" type="gint*"/>
+          <parameter name="data" type="guchar**"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkQuery">
+      <method name="depths" symbol="gdk_query_depths">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="depths" type="gint**"/>
+          <parameter name="count" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="visual_types" symbol="gdk_query_visual_types">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="visual_types" type="GdkVisualType**"/>
+          <parameter name="count" type="gint*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkRgb">
+      <method name="colormap_ditherable" symbol="gdk_rgb_colormap_ditherable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="cmap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="ditherable" symbol="gdk_rgb_ditherable">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="find_color" symbol="gdk_rgb_find_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="gc_set_background" symbol="gdk_rgb_gc_set_background">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="rgb" type="guint32"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="gc_set_foreground" symbol="gdk_rgb_gc_set_foreground">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+          <parameter name="rgb" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="get_colormap" symbol="gdk_rgb_get_colormap">
+        <return-type type="GdkColormap*"/>
+      </method>
+      <method name="get_visual" symbol="gdk_rgb_get_visual">
+        <return-type type="GdkVisual*"/>
+      </method>
+      <method deprecated="1" name="init" symbol="gdk_rgb_init">
+        <return-type type="void"/>
+      </method>
+      <method name="set_install" symbol="gdk_rgb_set_install">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="install" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_min_colors" symbol="gdk_rgb_set_min_colors">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="min_colors" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_verbose" symbol="gdk_rgb_set_verbose">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="verbose" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="xpixel_from_rgb" symbol="gdk_rgb_xpixel_from_rgb">
+        <return-type type="gulong"/>
+        <parameters>
+          <parameter name="rgb" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkSelection">
+      <method name="convert" symbol="gdk_selection_convert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="requestor" type="GdkWindow*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="owner_get" symbol="gdk_selection_owner_get">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="owner_get_for_display" symbol="gdk_selection_owner_get_for_display">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="owner_set" symbol="gdk_selection_owner_set">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="owner" type="GdkWindow*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+          <parameter name="send_event" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="owner_set_for_display" symbol="gdk_selection_owner_set_for_display">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="owner" type="GdkWindow*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+          <parameter name="send_event" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="property_get" symbol="gdk_selection_property_get">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="requestor" type="GdkWindow*"/>
+          <parameter name="data" type="guchar**"/>
+          <parameter name="prop_type" type="GdkAtom*"/>
+          <parameter name="prop_format" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="send_notify" symbol="gdk_selection_send_notify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="requestor" type="guint32"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="property" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="send_notify_for_display" symbol="gdk_selection_send_notify_for_display">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="requestor" type="guint32"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="property" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkSpawn">
+      <method name="command_line_on_screen" symbol="gdk_spawn_command_line_on_screen">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="command_line" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="on_screen" symbol="gdk_spawn_on_screen">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="working_directory" type="const-gchar*"/>
+          <parameter name="argv" type="gchar**"/>
+          <parameter name="envp" type="gchar**"/>
+          <parameter name="flags" type="GSpawnFlags"/>
+          <parameter name="child_setup" type="GSpawnChildSetupFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="child_pid" type="gint*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="on_screen_with_pipes" symbol="gdk_spawn_on_screen_with_pipes">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+          <parameter name="working_directory" type="const-gchar*"/>
+          <parameter name="argv" type="gchar**"/>
+          <parameter name="envp" type="gchar**"/>
+          <parameter name="flags" type="GSpawnFlags"/>
+          <parameter name="child_setup" type="GSpawnChildSetupFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="child_pid" type="gint*"/>
+          <parameter name="standard_input" type="gint*"/>
+          <parameter name="standard_output" type="gint*"/>
+          <parameter name="standard_error" type="gint*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkText">
+      <method deprecated="1" name="extents" symbol="gdk_text_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="text_length" type="gint"/>
+          <parameter name="lbearing" type="gint*"/>
+          <parameter name="rbearing" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="ascent" type="gint*"/>
+          <parameter name="descent" type="gint*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="extents_wc" symbol="gdk_text_extents_wc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="text" type="const-GdkWChar*"/>
+          <parameter name="text_length" type="gint"/>
+          <parameter name="lbearing" type="gint*"/>
+          <parameter name="rbearing" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="ascent" type="gint*"/>
+          <parameter name="descent" type="gint*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="height" symbol="gdk_text_height">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="measure" symbol="gdk_text_measure">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </method>
+      <method name="property_to_text_list" symbol="gdk_text_property_to_text_list">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="encoding" type="GdkAtom"/>
+          <parameter name="format" type="gint"/>
+          <parameter name="text" type="const-guchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="list" type="gchar***"/>
+        </parameters>
+      </method>
+      <method name="property_to_text_list_for_display" symbol="gdk_text_property_to_text_list_for_display">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="encoding" type="GdkAtom"/>
+          <parameter name="format" type="gint"/>
+          <parameter name="text" type="const-guchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="list" type="gchar***"/>
+        </parameters>
+      </method>
+      <method name="property_to_utf8_list" symbol="gdk_text_property_to_utf8_list">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="encoding" type="GdkAtom"/>
+          <parameter name="format" type="gint"/>
+          <parameter name="text" type="const-guchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="list" type="gchar***"/>
+        </parameters>
+      </method>
+      <method name="property_to_utf8_list_for_display" symbol="gdk_text_property_to_utf8_list_for_display">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="encoding" type="GdkAtom"/>
+          <parameter name="format" type="gint"/>
+          <parameter name="text" type="const-guchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="list" type="gchar***"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="width" symbol="gdk_text_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="width_wc" symbol="gdk_text_width_wc">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="font" type="GdkFont*"/>
+          <parameter name="text" type="const-GdkWChar*"/>
+          <parameter name="text_length" type="gint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GdkThreads">
+      <method name="enter" symbol="gdk_threads_enter">
+        <return-type type="void"/>
+      </method>
+      <method name="init" symbol="gdk_threads_init">
+        <return-type type="void"/>
+      </method>
+      <method name="leave" symbol="gdk_threads_leave">
+        <return-type type="void"/>
+      </method>
+      <method name="set_lock_functions" symbol="gdk_threads_set_lock_functions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="enter_fn" type="GCallback"/>
+          <parameter name="leave_fn" type="GCallback"/>
+        </parameters>
+      </method>
+    </struct>
+  </namespace>
+</api>

diff --git a/vapigen/packages/gdk-2.0/gdk-2.0.metadata b/vapigen/packages/gdk-2.0/gdk-2.0.metadata
new file mode 100644 (file)
index 0000000..39e9f61
--- /dev/null
+++ b/vapigen/packages/gdk-2.0/gdk-2.0.metadata
@@ -0,0 +1,3 @@
+Gdk cheader_filename="gdk/gdk.h"
+GdkAtom is_value_type="1"
+GdkColor is_value_type="1"

diff --git a/vapigen/packages/gdk-2.0/gdk-2.0.namespace b/vapigen/packages/gdk-2.0/gdk-2.0.namespace
new file mode 100644 (file)
index 0000000..2617db9
--- /dev/null
+++ b/vapigen/packages/gdk-2.0/gdk-2.0.namespace
@@ -0,0 +1 @@
+Gdk

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0-custom.vala b/vapigen/packages/gtk+-2.0/gtk+-2.0-custom.vala
new file mode 100644 (file)
index 0000000..823b8a1
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0-custom.vala
@@ -0,0 +1,28 @@
+/* gtk+-2.0.vala
+ *
+ * Copyright (C) 2006  Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ *     Jürg Billeter <j@bitron.ch>
+ */
+
+[CCode (cheader_filename = "gtk/gtk.h")]
+namespace Gtk {
+       public void init (ref int argc, out string[] argv);
+       public void main ();
+       public void main_quit ();
+}

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0.excludes b/vapigen/packages/gtk+-2.0/gtk+-2.0.excludes
new file mode 100644 (file)
index 0000000..e4d977c
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0.excludes
@@ -0,0 +1,68 @@
+gtkalias.h
+gtkbuiltincache.h
+gtkdndcursors.h
+gtkfilechooserdefault.c
+gtkfilechooserdefault.h
+gtkfilechooserembed.c
+gtkfilechooserembed.h
+gtkfilechooserentry.c
+gtkfilechooserentry.h
+gtkfilechoosersettings.c
+gtkfilechoosersettings.h
+gtkfilechooserutils.c
+gtkfilechooserutils.h
+gtkfilesystem.c
+gtkfilesystem.h
+gtkfilesystemmodel.c
+gtkfilesystemmodel.h
+gtkfilesystemunix.c
+gtkfilesystemunix.h
+gtkfilesystemwin32.c
+gtkfilesystemwin32.h
+gtkiconcache.c
+gtkiconcache.h
+gtkiconthemeparser.h
+gtkpathbar.c
+gtkpathbar.h
+gtkrbtree.c
+gtkrbtree.h
+gtksequence.c
+gtksequence.h
+gtktextbtree.c
+gtktextbtree.h
+gtktextsegment.c
+gtktextsegment.h
+gtktexttypes.c
+gtktexttypes.h
+gtktextutil.c
+gtktextutil.h
+gtkthemes.c
+gtkthemes.h
+gtktreedatalist.c
+gtktreedatalist.h
+gtkwindow-decorate.c
+gtkwindow-decorate.h
+gtkxembed.h
+xembed.h
+gtkclist.c
+gtkclist.h
+gtkctree.c
+gtkctree.h
+gtklist.c
+gtklist.h
+gtklistitem.c
+gtklistitem.h
+gtkoldeditable.c
+gtkoldeditable.h
+gtkpixmap.c
+gtkpixmap.h
+gtkpreview.c
+gtkpreview.h
+gtktext.c
+gtktext.h
+gtktipsquery.c
+gtktipsquery.h
+gtktree.c
+gtktree.h
+gtktreeitem.c
+gtktreeitem.h

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0.files b/vapigen/packages/gtk+-2.0/gtk+-2.0.files
new file mode 100644 (file)
index 0000000..a5699d8
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0.files
@@ -0,0 +1 @@
+gtk

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0.gidl b/vapigen/packages/gtk+-2.0/gtk+-2.0.gidl
new file mode 100644 (file)
index 0000000..4b8443f
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0.gidl
@@ -0,0 +1,26480 @@
+<?xml version="1.0"?>
+<api version="1.0">
+  <!--
+
+        This file was automatically generated.
+        Please DO NOT MODIFY THIS FILE, modify .metadata files instead.
+
+-->
+  <namespace name="Gtk">
+    <enum get-type="gtk_accel_flags_get_type" name="GtkAccelFlags" type="flags" type-name="GtkAccelFlags">
+      <member name="GTK_ACCEL_VISIBLE" value=""/>
+      <member name="GTK_ACCEL_LOCKED" value=""/>
+      <member name="GTK_ACCEL_MASK" value="0x07"/>
+    </enum>
+    <enum get-type="gtk_anchor_type_get_type" name="GtkAnchorType" type="enum" type-name="GtkAnchorType">
+      <member name="GTK_ANCHOR_CENTER" value=""/>
+      <member name="GTK_ANCHOR_NORTH" value=""/>
+      <member name="GTK_ANCHOR_NORTH_WEST" value=""/>
+      <member name="GTK_ANCHOR_NORTH_EAST" value=""/>
+      <member name="GTK_ANCHOR_SOUTH" value=""/>
+      <member name="GTK_ANCHOR_SOUTH_WEST" value=""/>
+      <member name="GTK_ANCHOR_SOUTH_EAST" value=""/>
+      <member name="GTK_ANCHOR_WEST" value=""/>
+      <member name="GTK_ANCHOR_EAST" value=""/>
+      <member name="GTK_ANCHOR_N" value=""/>
+      <member name="GTK_ANCHOR_NW" value=""/>
+      <member name="GTK_ANCHOR_NE" value=""/>
+      <member name="GTK_ANCHOR_S" value=""/>
+      <member name="GTK_ANCHOR_SW" value=""/>
+      <member name="GTK_ANCHOR_SE" value=""/>
+      <member name="GTK_ANCHOR_W" value=""/>
+      <member name="GTK_ANCHOR_E" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_arg_flags_get_type" name="GtkArgFlags" type="flags" type-name="GtkArgFlags">
+      <member name="GTK_ARG_READABLE" value="G_PARAM_READABLE"/>
+      <member name="GTK_ARG_WRITABLE" value="G_PARAM_WRITABLE"/>
+      <member name="GTK_ARG_CONSTRUCT" value="G_PARAM_CONSTRUCT"/>
+      <member name="GTK_ARG_CONSTRUCT_ONLY" value="G_PARAM_CONSTRUCT_ONLY"/>
+      <member name="GTK_ARG_CHILD_ARG" value=""/>
+    </enum>
+    <enum get-type="gtk_arrow_type_get_type" name="GtkArrowType" type="enum" type-name="GtkArrowType">
+      <member name="GTK_ARROW_UP" value=""/>
+      <member name="GTK_ARROW_DOWN" value=""/>
+      <member name="GTK_ARROW_LEFT" value=""/>
+      <member name="GTK_ARROW_RIGHT" value=""/>
+      <member name="GTK_ARROW_NONE" value=""/>
+    </enum>
+    <enum get-type="gtk_assistant_page_type_get_type" name="GtkAssistantPageType" type="enum" type-name="GtkAssistantPageType">
+      <member name="GTK_ASSISTANT_PAGE_CONTENT" value=""/>
+      <member name="GTK_ASSISTANT_PAGE_INTRO" value=""/>
+      <member name="GTK_ASSISTANT_PAGE_CONFIRM" value=""/>
+      <member name="GTK_ASSISTANT_PAGE_SUMMARY" value=""/>
+      <member name="GTK_ASSISTANT_PAGE_PROGRESS" value=""/>
+    </enum>
+    <enum get-type="gtk_attach_options_get_type" name="GtkAttachOptions" type="flags" type-name="GtkAttachOptions">
+      <member name="GTK_EXPAND" value=""/>
+      <member name="GTK_SHRINK" value=""/>
+      <member name="GTK_FILL" value=""/>
+    </enum>
+    <enum get-type="gtk_button_box_style_get_type" name="GtkButtonBoxStyle" type="enum" type-name="GtkButtonBoxStyle">
+      <member name="GTK_BUTTONBOX_DEFAULT_STYLE" value=""/>
+      <member name="GTK_BUTTONBOX_SPREAD" value=""/>
+      <member name="GTK_BUTTONBOX_EDGE" value=""/>
+      <member name="GTK_BUTTONBOX_START" value=""/>
+      <member name="GTK_BUTTONBOX_END" value=""/>
+    </enum>
+    <enum get-type="gtk_buttons_type_get_type" name="GtkButtonsType" type="enum" type-name="GtkButtonsType">
+      <member name="GTK_BUTTONS_NONE" value=""/>
+      <member name="GTK_BUTTONS_OK" value=""/>
+      <member name="GTK_BUTTONS_CLOSE" value=""/>
+      <member name="GTK_BUTTONS_CANCEL" value=""/>
+      <member name="GTK_BUTTONS_YES_NO" value=""/>
+      <member name="GTK_BUTTONS_OK_CANCEL" value=""/>
+    </enum>
+    <enum get-type="gtk_calendar_display_options_get_type" name="GtkCalendarDisplayOptions" type="flags" type-name="GtkCalendarDisplayOptions">
+      <member name="GTK_CALENDAR_SHOW_HEADING" value=""/>
+      <member name="GTK_CALENDAR_SHOW_DAY_NAMES" value=""/>
+      <member name="GTK_CALENDAR_NO_MONTH_CHANGE" value=""/>
+      <member name="GTK_CALENDAR_SHOW_WEEK_NUMBERS" value=""/>
+      <member name="GTK_CALENDAR_WEEK_START_MONDAY" value=""/>
+    </enum>
+    <enum get-type="gtk_cell_renderer_accel_mode_get_type" name="GtkCellRendererAccelMode" type="enum" type-name="GtkCellRendererAccelMode">
+      <member name="GTK_CELL_RENDERER_ACCEL_MODE_GTK" value=""/>
+      <member name="GTK_CELL_RENDERER_ACCEL_MODE_OTHER" value=""/>
+    </enum>
+    <enum get-type="gtk_cell_renderer_mode_get_type" name="GtkCellRendererMode" type="enum" type-name="GtkCellRendererMode">
+      <member name="GTK_CELL_RENDERER_MODE_INERT" value=""/>
+      <member name="GTK_CELL_RENDERER_MODE_ACTIVATABLE" value=""/>
+      <member name="GTK_CELL_RENDERER_MODE_EDITABLE" value=""/>
+    </enum>
+    <enum get-type="gtk_cell_renderer_state_get_type" name="GtkCellRendererState" type="flags" type-name="GtkCellRendererState">
+      <member name="GTK_CELL_RENDERER_SELECTED" value=""/>
+      <member name="GTK_CELL_RENDERER_PRELIT" value=""/>
+      <member name="GTK_CELL_RENDERER_INSENSITIVE" value=""/>
+      <member name="GTK_CELL_RENDERER_SORTED" value=""/>
+      <member name="GTK_CELL_RENDERER_FOCUSED" value=""/>
+    </enum>
+    <enum get-type="gtk_corner_type_get_type" name="GtkCornerType" type="enum" type-name="GtkCornerType">
+      <member name="GTK_CORNER_TOP_LEFT" value=""/>
+      <member name="GTK_CORNER_BOTTOM_LEFT" value=""/>
+      <member name="GTK_CORNER_TOP_RIGHT" value=""/>
+      <member name="GTK_CORNER_BOTTOM_RIGHT" value=""/>
+    </enum>
+    <enum get-type="gtk_curve_type_get_type" name="GtkCurveType" type="enum" type-name="GtkCurveType">
+      <member name="GTK_CURVE_TYPE_LINEAR" value=""/>
+      <member name="GTK_CURVE_TYPE_SPLINE" value=""/>
+      <member name="GTK_CURVE_TYPE_FREE" value=""/>
+    </enum>
+    <enum get-type="gtk_debug_flag_get_type" name="GtkDebugFlag" type="flags" type-name="GtkDebugFlag">
+      <member name="GTK_DEBUG_MISC" value=""/>
+      <member name="GTK_DEBUG_PLUGSOCKET" value=""/>
+      <member name="GTK_DEBUG_TEXT" value=""/>
+      <member name="GTK_DEBUG_TREE" value=""/>
+      <member name="GTK_DEBUG_UPDATES" value=""/>
+      <member name="GTK_DEBUG_KEYBINDINGS" value=""/>
+      <member name="GTK_DEBUG_MULTIHEAD" value=""/>
+      <member name="GTK_DEBUG_MODULES" value=""/>
+      <member name="GTK_DEBUG_GEOMETRY" value=""/>
+      <member name="GTK_DEBUG_ICONTHEME" value=""/>
+      <member name="GTK_DEBUG_PRINTING" value=""/>
+    </enum>
+    <enum get-type="gtk_delete_type_get_type" name="GtkDeleteType" type="enum" type-name="GtkDeleteType">
+      <member name="GTK_DELETE_CHARS" value=""/>
+      <member name="GTK_DELETE_WORD_ENDS" value=""/>
+      <member name="GTK_DELETE_WORDS" value=""/>
+      <member name="GTK_DELETE_DISPLAY_LINES" value=""/>
+      <member name="GTK_DELETE_DISPLAY_LINE_ENDS" value=""/>
+      <member name="GTK_DELETE_PARAGRAPH_ENDS" value=""/>
+      <member name="GTK_DELETE_PARAGRAPHS" value=""/>
+      <member name="GTK_DELETE_WHITESPACE" value=""/>
+    </enum>
+    <enum get-type="gtk_dest_defaults_get_type" name="GtkDestDefaults" type="flags" type-name="GtkDestDefaults">
+      <member name="GTK_DEST_DEFAULT_MOTION" value=""/>
+      <member name="GTK_DEST_DEFAULT_HIGHLIGHT" value=""/>
+      <member name="GTK_DEST_DEFAULT_DROP" value=""/>
+      <member name="GTK_DEST_DEFAULT_ALL" value="0x07"/>
+    </enum>
+    <enum get-type="gtk_dialog_flags_get_type" name="GtkDialogFlags" type="flags" type-name="GtkDialogFlags">
+      <member name="GTK_DIALOG_MODAL" value=""/>
+      <member name="GTK_DIALOG_DESTROY_WITH_PARENT" value=""/>
+      <member name="GTK_DIALOG_NO_SEPARATOR" value=""/>
+    </enum>
+    <enum get-type="gtk_direction_type_get_type" name="GtkDirectionType" type="enum" type-name="GtkDirectionType">
+      <member name="GTK_DIR_TAB_FORWARD" value=""/>
+      <member name="GTK_DIR_TAB_BACKWARD" value=""/>
+      <member name="GTK_DIR_UP" value=""/>
+      <member name="GTK_DIR_DOWN" value=""/>
+      <member name="GTK_DIR_LEFT" value=""/>
+      <member name="GTK_DIR_RIGHT" value=""/>
+    </enum>
+    <enum get-type="gtk_expander_style_get_type" name="GtkExpanderStyle" type="enum" type-name="GtkExpanderStyle">
+      <member name="GTK_EXPANDER_COLLAPSED" value=""/>
+      <member name="GTK_EXPANDER_SEMI_COLLAPSED" value=""/>
+      <member name="GTK_EXPANDER_SEMI_EXPANDED" value=""/>
+      <member name="GTK_EXPANDER_EXPANDED" value=""/>
+    </enum>
+    <enum get-type="gtk_file_chooser_action_get_type" name="GtkFileChooserAction" type="enum" type-name="GtkFileChooserAction">
+      <member name="GTK_FILE_CHOOSER_ACTION_OPEN" value=""/>
+      <member name="GTK_FILE_CHOOSER_ACTION_SAVE" value=""/>
+      <member name="GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER" value=""/>
+      <member name="GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER" value=""/>
+    </enum>
+    <enum get-type="gtk_file_chooser_confirmation_get_type" name="GtkFileChooserConfirmation" type="enum" type-name="GtkFileChooserConfirmation">
+      <member name="GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM" value=""/>
+      <member name="GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME" value=""/>
+      <member name="GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN" value=""/>
+    </enum>
+    <enum get-type="gtk_file_chooser_error_get_type" name="GtkFileChooserError" type="enum" type-name="GtkFileChooserError">
+      <member name="GTK_FILE_CHOOSER_ERROR_NONEXISTENT" value=""/>
+      <member name="GTK_FILE_CHOOSER_ERROR_BAD_FILENAME" value=""/>
+      <member name="GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS" value=""/>
+    </enum>
+    <enum get-type="gtk_file_filter_flags_get_type" name="GtkFileFilterFlags" type="flags" type-name="GtkFileFilterFlags">
+      <member name="GTK_FILE_FILTER_FILENAME" value=""/>
+      <member name="GTK_FILE_FILTER_URI" value=""/>
+      <member name="GTK_FILE_FILTER_DISPLAY_NAME" value=""/>
+      <member name="GTK_FILE_FILTER_MIME_TYPE" value=""/>
+    </enum>
+    <enum name="GtkIMPreeditStyle" type="enum" type-name="GtkIMPreeditStyle">
+      <member name="GTK_IM_PREEDIT_NOTHING" value=""/>
+      <member name="GTK_IM_PREEDIT_CALLBACK" value=""/>
+      <member name="GTK_IM_PREEDIT_NONE" value=""/>
+    </enum>
+    <enum name="GtkIMStatusStyle" type="enum" type-name="GtkIMStatusStyle">
+      <member name="GTK_IM_STATUS_NOTHING" value=""/>
+      <member name="GTK_IM_STATUS_CALLBACK" value=""/>
+      <member name="GTK_IM_STATUS_NONE" value=""/>
+    </enum>
+    <enum get-type="gtk_icon_lookup_flags_get_type" name="GtkIconLookupFlags" type="flags" type-name="GtkIconLookupFlags">
+      <member name="GTK_ICON_LOOKUP_NO_SVG" value=""/>
+      <member name="GTK_ICON_LOOKUP_FORCE_SVG" value=""/>
+      <member name="GTK_ICON_LOOKUP_USE_BUILTIN" value=""/>
+    </enum>
+    <enum get-type="gtk_icon_size_get_type" name="GtkIconSize" type="enum" type-name="GtkIconSize">
+      <member name="GTK_ICON_SIZE_INVALID" value=""/>
+      <member name="GTK_ICON_SIZE_MENU" value=""/>
+      <member name="GTK_ICON_SIZE_SMALL_TOOLBAR" value=""/>
+      <member name="GTK_ICON_SIZE_LARGE_TOOLBAR" value=""/>
+      <member name="GTK_ICON_SIZE_BUTTON" value=""/>
+      <member name="GTK_ICON_SIZE_DND" value=""/>
+      <member name="GTK_ICON_SIZE_DIALOG" value=""/>
+    </enum>
+    <enum get-type="gtk_icon_theme_error_get_type" name="GtkIconThemeError" type="enum" type-name="GtkIconThemeError">
+      <member name="GTK_ICON_THEME_NOT_FOUND" value=""/>
+      <member name="GTK_ICON_THEME_FAILED" value=""/>
+    </enum>
+    <enum get-type="gtk_icon_view_drop_position_get_type" name="GtkIconViewDropPosition" type="enum" type-name="GtkIconViewDropPosition">
+      <member name="GTK_ICON_VIEW_NO_DROP" value=""/>
+      <member name="GTK_ICON_VIEW_DROP_INTO" value=""/>
+      <member name="GTK_ICON_VIEW_DROP_LEFT" value=""/>
+      <member name="GTK_ICON_VIEW_DROP_RIGHT" value=""/>
+      <member name="GTK_ICON_VIEW_DROP_ABOVE" value=""/>
+      <member name="GTK_ICON_VIEW_DROP_BELOW" value=""/>
+    </enum>
+    <enum get-type="gtk_image_type_get_type" name="GtkImageType" type="enum" type-name="GtkImageType">
+      <member name="GTK_IMAGE_EMPTY" value=""/>
+      <member name="GTK_IMAGE_PIXMAP" value=""/>
+      <member name="GTK_IMAGE_IMAGE" value=""/>
+      <member name="GTK_IMAGE_PIXBUF" value=""/>
+      <member name="GTK_IMAGE_STOCK" value=""/>
+      <member name="GTK_IMAGE_ICON_SET" value=""/>
+      <member name="GTK_IMAGE_ANIMATION" value=""/>
+      <member name="GTK_IMAGE_ICON_NAME" value=""/>
+    </enum>
+    <enum get-type="gtk_justification_get_type" name="GtkJustification" type="enum" type-name="GtkJustification">
+      <member name="GTK_JUSTIFY_LEFT" value=""/>
+      <member name="GTK_JUSTIFY_RIGHT" value=""/>
+      <member name="GTK_JUSTIFY_CENTER" value=""/>
+      <member name="GTK_JUSTIFY_FILL" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_match_type_get_type" name="GtkMatchType" type="enum" type-name="GtkMatchType">
+      <member name="GTK_MATCH_ALL" value=""/>
+      <member name="GTK_MATCH_ALL_TAIL" value=""/>
+      <member name="GTK_MATCH_HEAD" value=""/>
+      <member name="GTK_MATCH_TAIL" value=""/>
+      <member name="GTK_MATCH_EXACT" value=""/>
+      <member name="GTK_MATCH_LAST" value=""/>
+    </enum>
+    <enum get-type="gtk_menu_direction_type_get_type" name="GtkMenuDirectionType" type="enum" type-name="GtkMenuDirectionType">
+      <member name="GTK_MENU_DIR_PARENT" value=""/>
+      <member name="GTK_MENU_DIR_CHILD" value=""/>
+      <member name="GTK_MENU_DIR_NEXT" value=""/>
+      <member name="GTK_MENU_DIR_PREV" value=""/>
+    </enum>
+    <enum get-type="gtk_message_type_get_type" name="GtkMessageType" type="enum" type-name="GtkMessageType">
+      <member name="GTK_MESSAGE_INFO" value=""/>
+      <member name="GTK_MESSAGE_WARNING" value=""/>
+      <member name="GTK_MESSAGE_QUESTION" value=""/>
+      <member name="GTK_MESSAGE_ERROR" value=""/>
+      <member name="GTK_MESSAGE_OTHER" value=""/>
+    </enum>
+    <enum get-type="gtk_metric_type_get_type" name="GtkMetricType" type="enum" type-name="GtkMetricType">
+      <member name="GTK_PIXELS" value=""/>
+      <member name="GTK_INCHES" value=""/>
+      <member name="GTK_CENTIMETERS" value=""/>
+    </enum>
+    <enum get-type="gtk_movement_step_get_type" name="GtkMovementStep" type="enum" type-name="GtkMovementStep">
+      <member name="GTK_MOVEMENT_LOGICAL_POSITIONS" value=""/>
+      <member name="GTK_MOVEMENT_VISUAL_POSITIONS" value=""/>
+      <member name="GTK_MOVEMENT_WORDS" value=""/>
+      <member name="GTK_MOVEMENT_DISPLAY_LINES" value=""/>
+      <member name="GTK_MOVEMENT_DISPLAY_LINE_ENDS" value=""/>
+      <member name="GTK_MOVEMENT_PARAGRAPHS" value=""/>
+      <member name="GTK_MOVEMENT_PARAGRAPH_ENDS" value=""/>
+      <member name="GTK_MOVEMENT_PAGES" value=""/>
+      <member name="GTK_MOVEMENT_BUFFER_ENDS" value=""/>
+      <member name="GTK_MOVEMENT_HORIZONTAL_PAGES" value=""/>
+    </enum>
+    <enum get-type="gtk_notebook_tab_get_type" name="GtkNotebookTab" type="enum" type-name="GtkNotebookTab">
+      <member name="GTK_NOTEBOOK_TAB_FIRST" value=""/>
+      <member name="GTK_NOTEBOOK_TAB_LAST" value=""/>
+    </enum>
+    <enum get-type="gtk_object_flags_get_type" name="GtkObjectFlags" type="flags" type-name="GtkObjectFlags">
+      <member name="GTK_IN_DESTRUCTION" value=""/>
+      <member name="GTK_FLOATING" value=""/>
+      <member name="GTK_RESERVED_1" value=""/>
+      <member name="GTK_RESERVED_2" value=""/>
+    </enum>
+    <enum get-type="gtk_orientation_get_type" name="GtkOrientation" type="enum" type-name="GtkOrientation">
+      <member name="GTK_ORIENTATION_HORIZONTAL" value=""/>
+      <member name="GTK_ORIENTATION_VERTICAL" value=""/>
+    </enum>
+    <enum get-type="gtk_pack_direction_get_type" name="GtkPackDirection" type="enum" type-name="GtkPackDirection">
+      <member name="GTK_PACK_DIRECTION_LTR" value=""/>
+      <member name="GTK_PACK_DIRECTION_RTL" value=""/>
+      <member name="GTK_PACK_DIRECTION_TTB" value=""/>
+      <member name="GTK_PACK_DIRECTION_BTT" value=""/>
+    </enum>
+    <enum get-type="gtk_pack_type_get_type" name="GtkPackType" type="enum" type-name="GtkPackType">
+      <member name="GTK_PACK_START" value=""/>
+      <member name="GTK_PACK_END" value=""/>
+    </enum>
+    <enum get-type="gtk_page_orientation_get_type" name="GtkPageOrientation" type="enum" type-name="GtkPageOrientation">
+      <member name="GTK_PAGE_ORIENTATION_PORTRAIT" value=""/>
+      <member name="GTK_PAGE_ORIENTATION_LANDSCAPE" value=""/>
+      <member name="GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT" value=""/>
+      <member name="GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE" value=""/>
+    </enum>
+    <enum get-type="gtk_page_set_get_type" name="GtkPageSet" type="enum" type-name="GtkPageSet">
+      <member name="GTK_PAGE_SET_ALL" value=""/>
+      <member name="GTK_PAGE_SET_EVEN" value=""/>
+      <member name="GTK_PAGE_SET_ODD" value=""/>
+    </enum>
+    <enum get-type="gtk_path_priority_type_get_type" name="GtkPathPriorityType" type="enum" type-name="GtkPathPriorityType">
+      <member name="GTK_PATH_PRIO_LOWEST" value="0"/>
+      <member name="GTK_PATH_PRIO_GTK" value="4"/>
+      <member name="GTK_PATH_PRIO_APPLICATION" value="8"/>
+      <member name="GTK_PATH_PRIO_THEME" value="10"/>
+      <member name="GTK_PATH_PRIO_RC" value="12"/>
+      <member name="GTK_PATH_PRIO_HIGHEST" value="15"/>
+    </enum>
+    <enum get-type="gtk_path_type_get_type" name="GtkPathType" type="enum" type-name="GtkPathType">
+      <member name="GTK_PATH_WIDGET" value=""/>
+      <member name="GTK_PATH_WIDGET_CLASS" value=""/>
+      <member name="GTK_PATH_CLASS" value=""/>
+    </enum>
+    <enum get-type="gtk_policy_type_get_type" name="GtkPolicyType" type="enum" type-name="GtkPolicyType">
+      <member name="GTK_POLICY_ALWAYS" value=""/>
+      <member name="GTK_POLICY_AUTOMATIC" value=""/>
+      <member name="GTK_POLICY_NEVER" value=""/>
+    </enum>
+    <enum get-type="gtk_position_type_get_type" name="GtkPositionType" type="enum" type-name="GtkPositionType">
+      <member name="GTK_POS_LEFT" value=""/>
+      <member name="GTK_POS_RIGHT" value=""/>
+      <member name="GTK_POS_TOP" value=""/>
+      <member name="GTK_POS_BOTTOM" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_preview_type_get_type" name="GtkPreviewType" type="enum" type-name="GtkPreviewType">
+      <member name="GTK_PREVIEW_COLOR" value=""/>
+      <member name="GTK_PREVIEW_GRAYSCALE" value=""/>
+    </enum>
+    <enum name="GtkPrintBackendError" type="enum" type-name="GtkPrintBackendError">
+      <member name="GTK_PRINT_BACKEND_ERROR_GENERIC" value=""/>
+    </enum>
+    <enum get-type="gtk_print_capabilities_get_type" name="GtkPrintCapabilities" type="flags" type-name="GtkPrintCapabilities">
+      <member name="GTK_PRINT_CAPABILITY_PAGE_SET" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_COPIES" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_COLLATE" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_REVERSE" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_SCALE" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_GENERATE_PDF" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_GENERATE_PS" value=""/>
+      <member name="GTK_PRINT_CAPABILITY_PREVIEW" value=""/>
+    </enum>
+    <enum get-type="gtk_print_duplex_get_type" name="GtkPrintDuplex" type="enum" type-name="GtkPrintDuplex">
+      <member name="GTK_PRINT_DUPLEX_SIMPLEX" value=""/>
+      <member name="GTK_PRINT_DUPLEX_HORIZONTAL" value=""/>
+      <member name="GTK_PRINT_DUPLEX_VERTICAL" value=""/>
+    </enum>
+    <enum get-type="gtk_print_error_get_type" name="GtkPrintError" type="enum" type-name="GtkPrintError">
+      <member name="GTK_PRINT_ERROR_GENERAL" value=""/>
+      <member name="GTK_PRINT_ERROR_INTERNAL_ERROR" value=""/>
+      <member name="GTK_PRINT_ERROR_NOMEM" value=""/>
+    </enum>
+    <enum get-type="gtk_print_operation_action_get_type" name="GtkPrintOperationAction" type="enum" type-name="GtkPrintOperationAction">
+      <member name="GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG" value=""/>
+      <member name="GTK_PRINT_OPERATION_ACTION_PRINT" value=""/>
+      <member name="GTK_PRINT_OPERATION_ACTION_PREVIEW" value=""/>
+      <member name="GTK_PRINT_OPERATION_ACTION_EXPORT" value=""/>
+    </enum>
+    <enum get-type="gtk_print_operation_result_get_type" name="GtkPrintOperationResult" type="enum" type-name="GtkPrintOperationResult">
+      <member name="GTK_PRINT_OPERATION_RESULT_ERROR" value=""/>
+      <member name="GTK_PRINT_OPERATION_RESULT_APPLY" value=""/>
+      <member name="GTK_PRINT_OPERATION_RESULT_CANCEL" value=""/>
+      <member name="GTK_PRINT_OPERATION_RESULT_IN_PROGRESS" value=""/>
+    </enum>
+    <enum get-type="gtk_print_pages_get_type" name="GtkPrintPages" type="enum" type-name="GtkPrintPages">
+      <member name="GTK_PRINT_PAGES_ALL" value=""/>
+      <member name="GTK_PRINT_PAGES_CURRENT" value=""/>
+      <member name="GTK_PRINT_PAGES_RANGES" value=""/>
+    </enum>
+    <enum get-type="gtk_print_quality_get_type" name="GtkPrintQuality" type="enum" type-name="GtkPrintQuality">
+      <member name="GTK_PRINT_QUALITY_LOW" value=""/>
+      <member name="GTK_PRINT_QUALITY_NORMAL" value=""/>
+      <member name="GTK_PRINT_QUALITY_HIGH" value=""/>
+      <member name="GTK_PRINT_QUALITY_DRAFT" value=""/>
+    </enum>
+    <enum get-type="gtk_print_status_get_type" name="GtkPrintStatus" type="enum" type-name="GtkPrintStatus">
+      <member name="GTK_PRINT_STATUS_INITIAL" value=""/>
+      <member name="GTK_PRINT_STATUS_PREPARING" value=""/>
+      <member name="GTK_PRINT_STATUS_GENERATING_DATA" value=""/>
+      <member name="GTK_PRINT_STATUS_SENDING_DATA" value=""/>
+      <member name="GTK_PRINT_STATUS_PENDING" value=""/>
+      <member name="GTK_PRINT_STATUS_PENDING_ISSUE" value=""/>
+      <member name="GTK_PRINT_STATUS_PRINTING" value=""/>
+      <member name="GTK_PRINT_STATUS_FINISHED" value=""/>
+      <member name="GTK_PRINT_STATUS_FINISHED_ABORTED" value=""/>
+    </enum>
+    <enum name="GtkPrinterOptionType" type="enum" type-name="GtkPrinterOptionType">
+      <member name="GTK_PRINTER_OPTION_TYPE_BOOLEAN" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_PICKONE" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_PICKONE_REAL" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_PICKONE_INT" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_PICKONE_STRING" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_ALTERNATIVE" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_STRING" value=""/>
+      <member name="GTK_PRINTER_OPTION_TYPE_FILESAVE" value=""/>
+    </enum>
+    <enum get-type="gtk_progress_bar_orientation_get_type" name="GtkProgressBarOrientation" type="enum" type-name="GtkProgressBarOrientation">
+      <member name="GTK_PROGRESS_LEFT_TO_RIGHT" value=""/>
+      <member name="GTK_PROGRESS_RIGHT_TO_LEFT" value=""/>
+      <member name="GTK_PROGRESS_BOTTOM_TO_TOP" value=""/>
+      <member name="GTK_PROGRESS_TOP_TO_BOTTOM" value=""/>
+    </enum>
+    <enum get-type="gtk_progress_bar_style_get_type" name="GtkProgressBarStyle" type="enum" type-name="GtkProgressBarStyle">
+      <member name="GTK_PROGRESS_CONTINUOUS" value=""/>
+      <member name="GTK_PROGRESS_DISCRETE" value=""/>
+    </enum>
+    <enum get-type="gtk_rc_flags_get_type" name="GtkRcFlags" type="flags" type-name="GtkRcFlags">
+      <member name="GTK_RC_FG" value=""/>
+      <member name="GTK_RC_BG" value=""/>
+      <member name="GTK_RC_TEXT" value=""/>
+      <member name="GTK_RC_BASE" value=""/>
+    </enum>
+    <enum get-type="gtk_rc_token_type_get_type" name="GtkRcTokenType" type="enum" type-name="GtkRcTokenType">
+      <member name="GTK_RC_TOKEN_INVALID" value="G_TOKEN_LAST"/>
+      <member name="GTK_RC_TOKEN_INCLUDE" value=""/>
+      <member name="GTK_RC_TOKEN_NORMAL" value=""/>
+      <member name="GTK_RC_TOKEN_ACTIVE" value=""/>
+      <member name="GTK_RC_TOKEN_PRELIGHT" value=""/>
+      <member name="GTK_RC_TOKEN_SELECTED" value=""/>
+      <member name="GTK_RC_TOKEN_INSENSITIVE" value=""/>
+      <member name="GTK_RC_TOKEN_FG" value=""/>
+      <member name="GTK_RC_TOKEN_BG" value=""/>
+      <member name="GTK_RC_TOKEN_TEXT" value=""/>
+      <member name="GTK_RC_TOKEN_BASE" value=""/>
+      <member name="GTK_RC_TOKEN_XTHICKNESS" value=""/>
+      <member name="GTK_RC_TOKEN_YTHICKNESS" value=""/>
+      <member name="GTK_RC_TOKEN_FONT" value=""/>
+      <member name="GTK_RC_TOKEN_FONTSET" value=""/>
+      <member name="GTK_RC_TOKEN_FONT_NAME" value=""/>
+      <member name="GTK_RC_TOKEN_BG_PIXMAP" value=""/>
+      <member name="GTK_RC_TOKEN_PIXMAP_PATH" value=""/>
+      <member name="GTK_RC_TOKEN_STYLE" value=""/>
+      <member name="GTK_RC_TOKEN_BINDING" value=""/>
+      <member name="GTK_RC_TOKEN_BIND" value=""/>
+      <member name="GTK_RC_TOKEN_WIDGET" value=""/>
+      <member name="GTK_RC_TOKEN_WIDGET_CLASS" value=""/>
+      <member name="GTK_RC_TOKEN_CLASS" value=""/>
+      <member name="GTK_RC_TOKEN_LOWEST" value=""/>
+      <member name="GTK_RC_TOKEN_GTK" value=""/>
+      <member name="GTK_RC_TOKEN_APPLICATION" value=""/>
+      <member name="GTK_RC_TOKEN_THEME" value=""/>
+      <member name="GTK_RC_TOKEN_RC" value=""/>
+      <member name="GTK_RC_TOKEN_HIGHEST" value=""/>
+      <member name="GTK_RC_TOKEN_ENGINE" value=""/>
+      <member name="GTK_RC_TOKEN_MODULE_PATH" value=""/>
+      <member name="GTK_RC_TOKEN_IM_MODULE_PATH" value=""/>
+      <member name="GTK_RC_TOKEN_IM_MODULE_FILE" value=""/>
+      <member name="GTK_RC_TOKEN_STOCK" value=""/>
+      <member name="GTK_RC_TOKEN_LTR" value=""/>
+      <member name="GTK_RC_TOKEN_RTL" value=""/>
+      <member name="GTK_RC_TOKEN_COLOR" value=""/>
+      <member name="GTK_RC_TOKEN_LAST" value=""/>
+    </enum>
+    <enum get-type="gtk_recent_chooser_error_get_type" name="GtkRecentChooserError" type="enum" type-name="GtkRecentChooserError">
+      <member name="GTK_RECENT_CHOOSER_ERROR_NOT_FOUND" value=""/>
+      <member name="GTK_RECENT_CHOOSER_ERROR_INVALID_URI" value=""/>
+    </enum>
+    <enum name="GtkRecentChooserProp" type="enum" type-name="GtkRecentChooserProp">
+      <member name="GTK_RECENT_CHOOSER_PROP_FIRST" value="0x3000"/>
+      <member name="GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_SHOW_TIPS" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_SHOW_ICONS" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_LIMIT" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_SORT_TYPE" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_FILTER" value=""/>
+      <member name="GTK_RECENT_CHOOSER_PROP_LAST" value=""/>
+    </enum>
+    <enum get-type="gtk_recent_filter_flags_get_type" name="GtkRecentFilterFlags" type="flags" type-name="GtkRecentFilterFlags">
+      <member name="GTK_RECENT_FILTER_URI" value=""/>
+      <member name="GTK_RECENT_FILTER_DISPLAY_NAME" value=""/>
+      <member name="GTK_RECENT_FILTER_MIME_TYPE" value=""/>
+      <member name="GTK_RECENT_FILTER_APPLICATION" value=""/>
+      <member name="GTK_RECENT_FILTER_GROUP" value=""/>
+      <member name="GTK_RECENT_FILTER_AGE" value=""/>
+    </enum>
+    <enum get-type="gtk_recent_manager_error_get_type" name="GtkRecentManagerError" type="enum" type-name="GtkRecentManagerError">
+      <member name="GTK_RECENT_MANAGER_ERROR_NOT_FOUND" value=""/>
+      <member name="GTK_RECENT_MANAGER_ERROR_INVALID_URI" value=""/>
+      <member name="GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING" value=""/>
+      <member name="GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED" value=""/>
+      <member name="GTK_RECENT_MANAGER_ERROR_READ" value=""/>
+      <member name="GTK_RECENT_MANAGER_ERROR_WRITE" value=""/>
+      <member name="GTK_RECENT_MANAGER_ERROR_UNKNOWN" value=""/>
+    </enum>
+    <enum get-type="gtk_recent_sort_type_get_type" name="GtkRecentSortType" type="enum" type-name="GtkRecentSortType">
+      <member name="GTK_RECENT_SORT_NONE" value="0"/>
+      <member name="GTK_RECENT_SORT_MRU" value=""/>
+      <member name="GTK_RECENT_SORT_LRU" value=""/>
+      <member name="GTK_RECENT_SORT_CUSTOM" value=""/>
+    </enum>
+    <enum get-type="gtk_relief_style_get_type" name="GtkReliefStyle" type="enum" type-name="GtkReliefStyle">
+      <member name="GTK_RELIEF_NORMAL" value=""/>
+      <member name="GTK_RELIEF_HALF" value=""/>
+      <member name="GTK_RELIEF_NONE" value=""/>
+    </enum>
+    <enum get-type="gtk_resize_mode_get_type" name="GtkResizeMode" type="enum" type-name="GtkResizeMode">
+      <member name="GTK_RESIZE_PARENT" value=""/>
+      <member name="GTK_RESIZE_QUEUE" value=""/>
+      <member name="GTK_RESIZE_IMMEDIATE" value=""/>
+    </enum>
+    <enum get-type="gtk_response_type_get_type" name="GtkResponseType" type="enum" type-name="GtkResponseType">
+      <member name="GTK_RESPONSE_NONE" value="-1"/>
+      <member name="GTK_RESPONSE_REJECT" value="-2"/>
+      <member name="GTK_RESPONSE_ACCEPT" value="-3"/>
+      <member name="GTK_RESPONSE_DELETE_EVENT" value="-4"/>
+      <member name="GTK_RESPONSE_OK" value="-5"/>
+      <member name="GTK_RESPONSE_CANCEL" value="-6"/>
+      <member name="GTK_RESPONSE_CLOSE" value="-7"/>
+      <member name="GTK_RESPONSE_YES" value="-8"/>
+      <member name="GTK_RESPONSE_NO" value="-9"/>
+      <member name="GTK_RESPONSE_APPLY" value="-10"/>
+      <member name="GTK_RESPONSE_HELP" value="-11"/>
+    </enum>
+    <enum get-type="gtk_scroll_step_get_type" name="GtkScrollStep" type="enum" type-name="GtkScrollStep">
+      <member name="GTK_SCROLL_STEPS" value=""/>
+      <member name="GTK_SCROLL_PAGES" value=""/>
+      <member name="GTK_SCROLL_ENDS" value=""/>
+      <member name="GTK_SCROLL_HORIZONTAL_STEPS" value=""/>
+      <member name="GTK_SCROLL_HORIZONTAL_PAGES" value=""/>
+      <member name="GTK_SCROLL_HORIZONTAL_ENDS" value=""/>
+    </enum>
+    <enum get-type="gtk_scroll_type_get_type" name="GtkScrollType" type="enum" type-name="GtkScrollType">
+      <member name="GTK_SCROLL_NONE" value=""/>
+      <member name="GTK_SCROLL_JUMP" value=""/>
+      <member name="GTK_SCROLL_STEP_BACKWARD" value=""/>
+      <member name="GTK_SCROLL_STEP_FORWARD" value=""/>
+      <member name="GTK_SCROLL_PAGE_BACKWARD" value=""/>
+      <member name="GTK_SCROLL_PAGE_FORWARD" value=""/>
+      <member name="GTK_SCROLL_STEP_UP" value=""/>
+      <member name="GTK_SCROLL_STEP_DOWN" value=""/>
+      <member name="GTK_SCROLL_PAGE_UP" value=""/>
+      <member name="GTK_SCROLL_PAGE_DOWN" value=""/>
+      <member name="GTK_SCROLL_STEP_LEFT" value=""/>
+      <member name="GTK_SCROLL_STEP_RIGHT" value=""/>
+      <member name="GTK_SCROLL_PAGE_LEFT" value=""/>
+      <member name="GTK_SCROLL_PAGE_RIGHT" value=""/>
+      <member name="GTK_SCROLL_START" value=""/>
+      <member name="GTK_SCROLL_END" value=""/>
+    </enum>
+    <enum get-type="gtk_selection_mode_get_type" name="GtkSelectionMode" type="enum" type-name="GtkSelectionMode">
+      <member name="GTK_SELECTION_NONE" value=""/>
+      <member name="GTK_SELECTION_SINGLE" value=""/>
+      <member name="GTK_SELECTION_BROWSE" value=""/>
+      <member name="GTK_SELECTION_MULTIPLE" value=""/>
+      <member name="GTK_SELECTION_EXTENDED" value=""/>
+    </enum>
+    <enum get-type="gtk_sensitivity_type_get_type" name="GtkSensitivityType" type="enum" type-name="GtkSensitivityType">
+      <member name="GTK_SENSITIVITY_AUTO" value=""/>
+      <member name="GTK_SENSITIVITY_ON" value=""/>
+      <member name="GTK_SENSITIVITY_OFF" value=""/>
+    </enum>
+    <enum get-type="gtk_shadow_type_get_type" name="GtkShadowType" type="enum" type-name="GtkShadowType">
+      <member name="GTK_SHADOW_NONE" value=""/>
+      <member name="GTK_SHADOW_IN" value=""/>
+      <member name="GTK_SHADOW_OUT" value=""/>
+      <member name="GTK_SHADOW_ETCHED_IN" value=""/>
+      <member name="GTK_SHADOW_ETCHED_OUT" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_side_type_get_type" name="GtkSideType" type="enum" type-name="GtkSideType">
+      <member name="GTK_SIDE_TOP" value=""/>
+      <member name="GTK_SIDE_BOTTOM" value=""/>
+      <member name="GTK_SIDE_LEFT" value=""/>
+      <member name="GTK_SIDE_RIGHT" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_signal_run_type_get_type" name="GtkSignalRunType" type="enum" type-name="GtkSignalRunType">
+      <member name="GTK_RUN_FIRST" value="G_SIGNAL_RUN_FIRST"/>
+      <member name="GTK_RUN_LAST" value="G_SIGNAL_RUN_LAST"/>
+      <member name="GTK_RUN_BOTH" value="GTK_RUN_FIRST | GTK_RUN_LAST"/>
+      <member name="GTK_RUN_NO_RECURSE" value="G_SIGNAL_NO_RECURSE"/>
+      <member name="GTK_RUN_ACTION" value="G_SIGNAL_ACTION"/>
+      <member name="GTK_RUN_NO_HOOKS" value="G_SIGNAL_NO_HOOKS"/>
+    </enum>
+    <enum get-type="gtk_size_group_mode_get_type" name="GtkSizeGroupMode" type="enum" type-name="GtkSizeGroupMode">
+      <member name="GTK_SIZE_GROUP_NONE" value=""/>
+      <member name="GTK_SIZE_GROUP_HORIZONTAL" value=""/>
+      <member name="GTK_SIZE_GROUP_VERTICAL" value=""/>
+      <member name="GTK_SIZE_GROUP_BOTH" value=""/>
+    </enum>
+    <enum get-type="gtk_sort_type_get_type" name="GtkSortType" type="enum" type-name="GtkSortType">
+      <member name="GTK_SORT_ASCENDING" value=""/>
+      <member name="GTK_SORT_DESCENDING" value=""/>
+    </enum>
+    <enum get-type="gtk_spin_button_update_policy_get_type" name="GtkSpinButtonUpdatePolicy" type="enum" type-name="GtkSpinButtonUpdatePolicy">
+      <member name="GTK_UPDATE_ALWAYS" value=""/>
+      <member name="GTK_UPDATE_IF_VALID" value=""/>
+    </enum>
+    <enum get-type="gtk_spin_type_get_type" name="GtkSpinType" type="enum" type-name="GtkSpinType">
+      <member name="GTK_SPIN_STEP_FORWARD" value=""/>
+      <member name="GTK_SPIN_STEP_BACKWARD" value=""/>
+      <member name="GTK_SPIN_PAGE_FORWARD" value=""/>
+      <member name="GTK_SPIN_PAGE_BACKWARD" value=""/>
+      <member name="GTK_SPIN_HOME" value=""/>
+      <member name="GTK_SPIN_END" value=""/>
+      <member name="GTK_SPIN_USER_DEFINED" value=""/>
+    </enum>
+    <enum get-type="gtk_state_type_get_type" name="GtkStateType" type="enum" type-name="GtkStateType">
+      <member name="GTK_STATE_NORMAL" value=""/>
+      <member name="GTK_STATE_ACTIVE" value=""/>
+      <member name="GTK_STATE_PRELIGHT" value=""/>
+      <member name="GTK_STATE_SELECTED" value=""/>
+      <member name="GTK_STATE_INSENSITIVE" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_submenu_direction_get_type" name="GtkSubmenuDirection" type="enum" type-name="GtkSubmenuDirection">
+      <member name="GTK_DIRECTION_LEFT" value=""/>
+      <member name="GTK_DIRECTION_RIGHT" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_submenu_placement_get_type" name="GtkSubmenuPlacement" type="enum" type-name="GtkSubmenuPlacement">
+      <member name="GTK_TOP_BOTTOM" value=""/>
+      <member name="GTK_LEFT_RIGHT" value=""/>
+    </enum>
+    <enum get-type="gtk_target_flags_get_type" name="GtkTargetFlags" type="flags" type-name="GtkTargetFlags">
+      <member name="GTK_TARGET_SAME_APP" value=""/>
+      <member name="GTK_TARGET_SAME_WIDGET" value=""/>
+    </enum>
+    <enum get-type="gtk_text_buffer_target_info_get_type" name="GtkTextBufferTargetInfo" type="enum" type-name="GtkTextBufferTargetInfo">
+      <member name="GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS" value="G_MAXUINT - 0"/>
+      <member name="GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT" value="G_MAXUINT - 1"/>
+      <member name="GTK_TEXT_BUFFER_TARGET_INFO_TEXT" value="G_MAXUINT - 2"/>
+    </enum>
+    <enum get-type="gtk_text_direction_get_type" name="GtkTextDirection" type="enum" type-name="GtkTextDirection">
+      <member name="GTK_TEXT_DIR_NONE" value=""/>
+      <member name="GTK_TEXT_DIR_LTR" value=""/>
+      <member name="GTK_TEXT_DIR_RTL" value=""/>
+    </enum>
+    <enum get-type="gtk_text_search_flags_get_type" name="GtkTextSearchFlags" type="flags" type-name="GtkTextSearchFlags">
+      <member name="GTK_TEXT_SEARCH_VISIBLE_ONLY" value=""/>
+      <member name="GTK_TEXT_SEARCH_TEXT_ONLY" value=""/>
+    </enum>
+    <enum get-type="gtk_text_window_type_get_type" name="GtkTextWindowType" type="enum" type-name="GtkTextWindowType">
+      <member name="GTK_TEXT_WINDOW_PRIVATE" value=""/>
+      <member name="GTK_TEXT_WINDOW_WIDGET" value=""/>
+      <member name="GTK_TEXT_WINDOW_TEXT" value=""/>
+      <member name="GTK_TEXT_WINDOW_LEFT" value=""/>
+      <member name="GTK_TEXT_WINDOW_RIGHT" value=""/>
+      <member name="GTK_TEXT_WINDOW_TOP" value=""/>
+      <member name="GTK_TEXT_WINDOW_BOTTOM" value=""/>
+    </enum>
+    <enum deprecated="1" get-type="gtk_toolbar_child_type_get_type" name="GtkToolbarChildType" type="enum" type-name="GtkToolbarChildType">
+      <member name="GTK_TOOLBAR_CHILD_SPACE" value=""/>
+      <member name="GTK_TOOLBAR_CHILD_BUTTON" value=""/>
+      <member name="GTK_TOOLBAR_CHILD_TOGGLEBUTTON" value=""/>
+      <member name="GTK_TOOLBAR_CHILD_RADIOBUTTON" value=""/>
+      <member name="GTK_TOOLBAR_CHILD_WIDGET" value=""/>
+    </enum>
+    <enum get-type="gtk_toolbar_space_style_get_type" name="GtkToolbarSpaceStyle" type="enum" type-name="GtkToolbarSpaceStyle">
+      <member name="GTK_TOOLBAR_SPACE_EMPTY" value=""/>
+      <member name="GTK_TOOLBAR_SPACE_LINE" value=""/>
+    </enum>
+    <enum get-type="gtk_toolbar_style_get_type" name="GtkToolbarStyle" type="enum" type-name="GtkToolbarStyle">
+      <member name="GTK_TOOLBAR_ICONS" value=""/>
+      <member name="GTK_TOOLBAR_TEXT" value=""/>
+      <member name="GTK_TOOLBAR_BOTH" value=""/>
+      <member name="GTK_TOOLBAR_BOTH_HORIZ" value=""/>
+    </enum>
+    <enum get-type="gtk_tree_model_flags_get_type" name="GtkTreeModelFlags" type="flags" type-name="GtkTreeModelFlags">
+      <member name="GTK_TREE_MODEL_ITERS_PERSIST" value=""/>
+      <member name="GTK_TREE_MODEL_LIST_ONLY" value=""/>
+    </enum>
+    <enum get-type="gtk_tree_view_column_sizing_get_type" name="GtkTreeViewColumnSizing" type="enum" type-name="GtkTreeViewColumnSizing">
+      <member name="GTK_TREE_VIEW_COLUMN_GROW_ONLY" value=""/>
+      <member name="GTK_TREE_VIEW_COLUMN_AUTOSIZE" value=""/>
+      <member name="GTK_TREE_VIEW_COLUMN_FIXED" value=""/>
+    </enum>
+    <enum get-type="gtk_tree_view_drop_position_get_type" name="GtkTreeViewDropPosition" type="enum" type-name="GtkTreeViewDropPosition">
+      <member name="GTK_TREE_VIEW_DROP_BEFORE" value=""/>
+      <member name="GTK_TREE_VIEW_DROP_AFTER" value=""/>
+      <member name="GTK_TREE_VIEW_DROP_INTO_OR_BEFORE" value=""/>
+      <member name="GTK_TREE_VIEW_DROP_INTO_OR_AFTER" value=""/>
+    </enum>
+    <enum get-type="gtk_tree_view_grid_lines_get_type" name="GtkTreeViewGridLines" type="enum" type-name="GtkTreeViewGridLines">
+      <member name="GTK_TREE_VIEW_GRID_LINES_NONE" value=""/>
+      <member name="GTK_TREE_VIEW_GRID_LINES_HORIZONTAL" value=""/>
+      <member name="GTK_TREE_VIEW_GRID_LINES_VERTICAL" value=""/>
+      <member name="GTK_TREE_VIEW_GRID_LINES_BOTH" value=""/>
+    </enum>
+    <enum name="GtkUIManagerItemType" type="flags" type-name="GtkUIManagerItemType">
+      <member name="GTK_UI_MANAGER_AUTO" value="0"/>
+      <member name="GTK_UI_MANAGER_MENUBAR" value=""/>
+      <member name="GTK_UI_MANAGER_MENU" value=""/>
+      <member name="GTK_UI_MANAGER_TOOLBAR" value=""/>
+      <member name="GTK_UI_MANAGER_PLACEHOLDER" value=""/>
+      <member name="GTK_UI_MANAGER_POPUP" value=""/>
+      <member name="GTK_UI_MANAGER_MENUITEM" value=""/>
+      <member name="GTK_UI_MANAGER_TOOLITEM" value=""/>
+      <member name="GTK_UI_MANAGER_SEPARATOR" value=""/>
+      <member name="GTK_UI_MANAGER_ACCELERATOR" value=""/>
+    </enum>
+    <enum get-type="gtk_unit_get_type" name="GtkUnit" type="enum" type-name="GtkUnit">
+      <member name="GTK_UNIT_PIXEL" value=""/>
+      <member name="GTK_UNIT_POINTS" value=""/>
+      <member name="GTK_UNIT_INCH" value=""/>
+      <member name="GTK_UNIT_MM" value=""/>
+    </enum>
+    <enum get-type="gtk_update_type_get_type" name="GtkUpdateType" type="enum" type-name="GtkUpdateType">
+      <member name="GTK_UPDATE_CONTINUOUS" value=""/>
+      <member name="GTK_UPDATE_DISCONTINUOUS" value=""/>
+      <member name="GTK_UPDATE_DELAYED" value=""/>
+    </enum>
+    <enum get-type="gtk_visibility_get_type" name="GtkVisibility" type="enum" type-name="GtkVisibility">
+      <member name="GTK_VISIBILITY_NONE" value=""/>
+      <member name="GTK_VISIBILITY_PARTIAL" value=""/>
+      <member name="GTK_VISIBILITY_FULL" value=""/>
+    </enum>
+    <enum get-type="gtk_widget_flags_get_type" name="GtkWidgetFlags" type="flags" type-name="GtkWidgetFlags">
+      <member name="GTK_TOPLEVEL" value=""/>
+      <member name="GTK_NO_WINDOW" value=""/>
+      <member name="GTK_REALIZED" value=""/>
+      <member name="GTK_MAPPED" value=""/>
+      <member name="GTK_VISIBLE" value=""/>
+      <member name="GTK_SENSITIVE" value=""/>
+      <member name="GTK_PARENT_SENSITIVE" value=""/>
+      <member name="GTK_CAN_FOCUS" value=""/>
+      <member name="GTK_HAS_FOCUS" value=""/>
+      <member name="GTK_CAN_DEFAULT" value=""/>
+      <member name="GTK_HAS_DEFAULT" value=""/>
+      <member name="GTK_HAS_GRAB" value=""/>
+      <member name="GTK_RC_STYLE" value=""/>
+      <member name="GTK_COMPOSITE_CHILD" value=""/>
+      <member name="GTK_NO_REPARENT" value=""/>
+      <member name="GTK_APP_PAINTABLE" value=""/>
+      <member name="GTK_RECEIVES_DEFAULT" value=""/>
+      <member name="GTK_DOUBLE_BUFFERED" value=""/>
+      <member name="GTK_NO_SHOW_ALL" value=""/>
+    </enum>
+    <enum get-type="gtk_widget_help_type_get_type" name="GtkWidgetHelpType" type="enum" type-name="GtkWidgetHelpType">
+      <member name="GTK_WIDGET_HELP_TOOLTIP" value=""/>
+      <member name="GTK_WIDGET_HELP_WHATS_THIS" value=""/>
+    </enum>
+    <enum name="GtkWin32EmbedMessageType" type="enum" type-name="GtkWin32EmbedMessageType">
+      <member name="GTK_WIN32_EMBED_WINDOW_ACTIVATE" value=""/>
+      <member name="GTK_WIN32_EMBED_WINDOW_DEACTIVATE" value=""/>
+      <member name="GTK_WIN32_EMBED_FOCUS_IN" value=""/>
+      <member name="GTK_WIN32_EMBED_FOCUS_OUT" value=""/>
+      <member name="GTK_WIN32_EMBED_MODALITY_ON" value=""/>
+      <member name="GTK_WIN32_EMBED_MODALITY_OFF" value=""/>
+      <member name="GTK_WIN32_EMBED_PARENT_NOTIFY" value=""/>
+      <member name="GTK_WIN32_EMBED_EVENT_PLUG_MAPPED" value=""/>
+      <member name="GTK_WIN32_EMBED_PLUG_RESIZED" value=""/>
+      <member name="GTK_WIN32_EMBED_REQUEST_FOCUS" value=""/>
+      <member name="GTK_WIN32_EMBED_FOCUS_NEXT" value=""/>
+      <member name="GTK_WIN32_EMBED_FOCUS_PREV" value=""/>
+      <member name="GTK_WIN32_EMBED_GRAB_KEY" value=""/>
+      <member name="GTK_WIN32_EMBED_UNGRAB_KEY" value=""/>
+      <member name="GTK_WIN32_EMBED_LAST" value=""/>
+    </enum>
+    <enum get-type="gtk_window_position_get_type" name="GtkWindowPosition" type="enum" type-name="GtkWindowPosition">
+      <member name="GTK_WIN_POS_NONE" value=""/>
+      <member name="GTK_WIN_POS_CENTER" value=""/>
+      <member name="GTK_WIN_POS_MOUSE" value=""/>
+      <member name="GTK_WIN_POS_CENTER_ALWAYS" value=""/>
+      <member name="GTK_WIN_POS_CENTER_ON_PARENT" value=""/>
+    </enum>
+    <enum get-type="gtk_window_type_get_type" name="GtkWindowType" type="enum" type-name="GtkWindowType">
+      <member name="GTK_WINDOW_TOPLEVEL" value=""/>
+      <member name="GTK_WINDOW_POPUP" value=""/>
+    </enum>
+    <enum get-type="gtk_wrap_mode_get_type" name="GtkWrapMode" type="enum" type-name="GtkWrapMode">
+      <member name="GTK_WRAP_NONE" value=""/>
+      <member name="GTK_WRAP_CHAR" value=""/>
+      <member name="GTK_WRAP_WORD" value=""/>
+      <member name="GTK_WRAP_WORD_CHAR" value=""/>
+    </enum>
+    <callback name="GtkAboutDialogActivateLinkFunc" type-name="GtkAboutDialogActivateLinkFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="about" type="GtkAboutDialog*"/>
+        <parameter name="link" type="const-gchar*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkAccelGroupActivate" type-name="GtkAccelGroupActivate">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="accel_group" type="GtkAccelGroup*"/>
+        <parameter name="acceleratable" type="GObject*"/>
+        <parameter name="keyval" type="guint"/>
+        <parameter name="modifier" type="GdkModifierType"/>
+      </parameters>
+    </callback>
+    <callback name="GtkAccelGroupFindFunc" type-name="GtkAccelGroupFindFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="key" type="GtkAccelKey*"/>
+        <parameter name="closure" type="GClosure*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkAccelMapForeach" type-name="GtkAccelMapForeach">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="data" type="gpointer"/>
+        <parameter name="accel_path" type="const-gchar*"/>
+        <parameter name="accel_key" type="guint"/>
+        <parameter name="accel_mods" type="GdkModifierType"/>
+        <parameter name="changed" type="gboolean"/>
+      </parameters>
+    </callback>
+    <callback name="GtkAssistantPageFunc" type-name="GtkAssistantPageFunc">
+      <return-type type="gint"/>
+      <parameters>
+        <parameter name="current_page" type="gint"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkCallback" type-name="GtkCallback">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="widget" type="GtkWidget*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkCallbackMarshal" type-name="GtkCallbackMarshal">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="object" type="GtkObject*"/>
+        <parameter name="data" type="gpointer"/>
+        <parameter name="n_args" type="guint"/>
+        <parameter name="args" type="GtkArg*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkCellLayoutDataFunc" type-name="GtkCellLayoutDataFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="cell_layout" type="GtkCellLayout*"/>
+        <parameter name="cell" type="GtkCellRenderer*"/>
+        <parameter name="tree_model" type="GtkTreeModel*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardClearFunc" type-name="GtkClipboardClearFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="user_data_or_owner" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardGetFunc" type-name="GtkClipboardGetFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="selection_data" type="GtkSelectionData*"/>
+        <parameter name="info" type="guint"/>
+        <parameter name="user_data_or_owner" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardImageReceivedFunc" type-name="GtkClipboardImageReceivedFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="pixbuf" type="GdkPixbuf*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardReceivedFunc" type-name="GtkClipboardReceivedFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="selection_data" type="GtkSelectionData*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardRichTextReceivedFunc" type-name="GtkClipboardRichTextReceivedFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="format" type="GdkAtom"/>
+        <parameter name="text" type="const-guint8*"/>
+        <parameter name="length" type="gsize"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardTargetsReceivedFunc" type-name="GtkClipboardTargetsReceivedFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="atoms" type="GdkAtom*"/>
+        <parameter name="n_atoms" type="gint"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkClipboardTextReceivedFunc" type-name="GtkClipboardTextReceivedFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="clipboard" type="GtkClipboard*"/>
+        <parameter name="text" type="const-gchar*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkColorSelectionChangePaletteFunc" type-name="GtkColorSelectionChangePaletteFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="colors" type="const-GdkColor*"/>
+        <parameter name="n_colors" type="gint"/>
+      </parameters>
+    </callback>
+    <callback name="GtkColorSelectionChangePaletteWithScreenFunc" type-name="GtkColorSelectionChangePaletteWithScreenFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="screen" type="GdkScreen*"/>
+        <parameter name="colors" type="const-GdkColor*"/>
+        <parameter name="n_colors" type="gint"/>
+      </parameters>
+    </callback>
+    <callback name="GtkDestroyNotify" type-name="GtkDestroyNotify">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkEntryCompletionMatchFunc" type-name="GtkEntryCompletionMatchFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="completion" type="GtkEntryCompletion*"/>
+        <parameter name="key" type="const-gchar*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkFileFilterFunc" type-name="GtkFileFilterFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="filter_info" type="const-GtkFileFilterInfo*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkFunction" type-name="GtkFunction">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkIconViewForeachFunc" type-name="GtkIconViewForeachFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="icon_view" type="GtkIconView*"/>
+        <parameter name="path" type="GtkTreePath*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkItemFactoryCallback" type-name="GtkItemFactoryCallback">
+      <return-type type="void"/>
+    </callback>
+    <callback name="GtkItemFactoryCallback1" type-name="GtkItemFactoryCallback1">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="callback_data" type="gpointer"/>
+        <parameter name="callback_action" type="guint"/>
+        <parameter name="widget" type="GtkWidget*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkItemFactoryCallback2" type-name="GtkItemFactoryCallback2">
+      <return-type type="void"/>
+    </callback>
+    <callback name="GtkKeySnoopFunc" type-name="GtkKeySnoopFunc">
+      <return-type type="gint"/>
+      <parameters>
+        <parameter name="grab_widget" type="GtkWidget*"/>
+        <parameter name="event" type="GdkEventKey*"/>
+        <parameter name="func_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkLinkButtonUriFunc" type-name="GtkLinkButtonUriFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="button" type="GtkLinkButton*"/>
+        <parameter name="link" type="const-gchar*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkMenuCallback" type-name="GtkMenuCallback">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="widget" type="GtkWidget*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkMenuDetachFunc" type-name="GtkMenuDetachFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="attach_widget" type="GtkWidget*"/>
+        <parameter name="menu" type="GtkMenu*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkMenuPositionFunc" type-name="GtkMenuPositionFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="menu" type="GtkMenu*"/>
+        <parameter name="x" type="gint*"/>
+        <parameter name="y" type="gint*"/>
+        <parameter name="push_in" type="gboolean*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkMnemonicHashForeach" type-name="GtkMnemonicHashForeach">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="keyval" type="guint"/>
+        <parameter name="targets" type="GSList*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkModuleDisplayInitFunc" type-name="GtkModuleDisplayInitFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="display" type="GdkDisplay*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkModuleInitFunc" type-name="GtkModuleInitFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="argc" type="gint*"/>
+        <parameter name="argv" type="gchar***"/>
+      </parameters>
+    </callback>
+    <callback name="GtkNotebookWindowCreationFunc" type-name="GtkNotebookWindowCreationFunc">
+      <return-type type="GtkNotebook*"/>
+      <parameters>
+        <parameter name="source" type="GtkNotebook*"/>
+        <parameter name="page" type="GtkWidget*"/>
+        <parameter name="x" type="gint"/>
+        <parameter name="y" type="gint"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkPageSetupDoneFunc" type-name="GtkPageSetupDoneFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="page_setup" type="GtkPageSetup*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkPrintFunc" type-name="GtkPrintFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="func_data" type="gpointer"/>
+        <parameter name="str" type="const-gchar*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkPrintJobCompleteFunc" type-name="GtkPrintJobCompleteFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="print_job" type="GtkPrintJob*"/>
+        <parameter name="user_data" type="gpointer"/>
+        <parameter name="error" type="GError*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkPrintSettingsFunc" type-name="GtkPrintSettingsFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="key" type="const-gchar*"/>
+        <parameter name="value" type="const-gchar*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkPrinterFunc" type-name="GtkPrinterFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="printer" type="GtkPrinter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkPrinterOptionSetFunc" type-name="GtkPrinterOptionSetFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="option" type="GtkPrinterOption*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkRcPropertyParser" type-name="GtkRcPropertyParser">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="pspec" type="const-GParamSpec*"/>
+        <parameter name="rc_string" type="const-GString*"/>
+        <parameter name="property_value" type="GValue*"/>
+      </parameters>
+    </callback>
+    <callback name="GtkRecentFilterFunc" type-name="GtkRecentFilterFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="filter_info" type="const-GtkRecentFilterInfo*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkRecentSortFunc" type-name="GtkRecentSortFunc">
+      <return-type type="gint"/>
+      <parameters>
+        <parameter name="a" type="GtkRecentInfo*"/>
+        <parameter name="b" type="GtkRecentInfo*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkSignalFunc" type-name="GtkSignalFunc">
+      <return-type type="void"/>
+    </callback>
+    <callback name="GtkTextBufferDeserializeFunc" type-name="GtkTextBufferDeserializeFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="register_buffer" type="GtkTextBuffer*"/>
+        <parameter name="content_buffer" type="GtkTextBuffer*"/>
+        <parameter name="iter" type="GtkTextIter*"/>
+        <parameter name="data" type="const-guint8*"/>
+        <parameter name="length" type="gsize"/>
+        <parameter name="create_tags" type="gboolean"/>
+        <parameter name="user_data" type="gpointer"/>
+        <parameter name="error" type="GError**"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTextBufferSerializeFunc" type-name="GtkTextBufferSerializeFunc">
+      <return-type type="guint8*"/>
+      <parameters>
+        <parameter name="register_buffer" type="GtkTextBuffer*"/>
+        <parameter name="content_buffer" type="GtkTextBuffer*"/>
+        <parameter name="start" type="const-GtkTextIter*"/>
+        <parameter name="end" type="const-GtkTextIter*"/>
+        <parameter name="length" type="gsize*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTextCharPredicate" type-name="GtkTextCharPredicate">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="ch" type="gunichar"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTextTagTableForeach" type-name="GtkTextTagTableForeach">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="tag" type="GtkTextTag*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTranslateFunc" type-name="GtkTranslateFunc">
+      <return-type type="gchar*"/>
+      <parameters>
+        <parameter name="path" type="const-gchar*"/>
+        <parameter name="func_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeCellDataFunc" type-name="GtkTreeCellDataFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        <parameter name="cell" type="GtkCellRenderer*"/>
+        <parameter name="tree_model" type="GtkTreeModel*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeDestroyCountFunc" type-name="GtkTreeDestroyCountFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="tree_view" type="GtkTreeView*"/>
+        <parameter name="path" type="GtkTreePath*"/>
+        <parameter name="children" type="gint"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeIterCompareFunc" type-name="GtkTreeIterCompareFunc">
+      <return-type type="gint"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="a" type="GtkTreeIter*"/>
+        <parameter name="b" type="GtkTreeIter*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeModelFilterModifyFunc" type-name="GtkTreeModelFilterModifyFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="value" type="GValue*"/>
+        <parameter name="column" type="gint"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeModelFilterVisibleFunc" type-name="GtkTreeModelFilterVisibleFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeModelForeachFunc" type-name="GtkTreeModelForeachFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="path" type="GtkTreePath*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeSelectionForeachFunc" type-name="GtkTreeSelectionForeachFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="path" type="GtkTreePath*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeSelectionFunc" type-name="GtkTreeSelectionFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="selection" type="GtkTreeSelection*"/>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="path" type="GtkTreePath*"/>
+        <parameter name="path_currently_selected" type="gboolean"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeViewColumnDropFunc" type-name="GtkTreeViewColumnDropFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="tree_view" type="GtkTreeView*"/>
+        <parameter name="column" type="GtkTreeViewColumn*"/>
+        <parameter name="prev_column" type="GtkTreeViewColumn*"/>
+        <parameter name="next_column" type="GtkTreeViewColumn*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeViewMappingFunc" type-name="GtkTreeViewMappingFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="tree_view" type="GtkTreeView*"/>
+        <parameter name="path" type="GtkTreePath*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeViewRowSeparatorFunc" type-name="GtkTreeViewRowSeparatorFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeViewSearchEqualFunc" type-name="GtkTreeViewSearchEqualFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="model" type="GtkTreeModel*"/>
+        <parameter name="column" type="gint"/>
+        <parameter name="key" type="const-gchar*"/>
+        <parameter name="iter" type="GtkTreeIter*"/>
+        <parameter name="search_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkTreeViewSearchPositionFunc" type-name="GtkTreeViewSearchPositionFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="tree_view" type="GtkTreeView*"/>
+        <parameter name="search_dialog" type="GtkWidget*"/>
+        <parameter name="user_data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="GtkWindowKeysForeachFunc" type-name="GtkWindowKeysForeachFunc">
+      <return-type type="void"/>
+      <parameters>
+        <parameter name="window" type="GtkWindow*"/>
+        <parameter name="keyval" type="guint"/>
+        <parameter name="modifiers" type="GdkModifierType"/>
+        <parameter name="is_mnemonic" type="gboolean"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <interface get-type="" name="GtkCellEditable" type-name="GtkCellEditable">
+      <signal name="editing_done" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_editable" type="GtkCellEditable*"/>
+        </parameters>
+      </signal>
+      <signal name="remove_widget" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_editable" type="GtkCellEditable*"/>
+        </parameters>
+      </signal>
+      <vfunc name="start_editing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_editable" type="GtkCellEditable*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </vfunc>
+      <method name="editing_done" symbol="gtk_cell_editable_editing_done">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_editable" type="GtkCellEditable*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_cell_editable_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="remove_widget" symbol="gtk_cell_editable_remove_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_editable" type="GtkCellEditable*"/>
+        </parameters>
+      </method>
+      <method name="start_editing" symbol="gtk_cell_editable_start_editing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_editable" type="GtkCellEditable*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkCellLayout" type-name="GtkCellLayout">
+      <vfunc name="pack_start">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="pack_end">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="add_attribute">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="attribute" type="const-gchar*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_cell_data_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="func" type="GtkCellLayoutDataFunc"/>
+          <parameter name="func_data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="clear_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="reorder">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="add_attribute" symbol="gtk_cell_layout_add_attribute">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="attribute" type="const-gchar*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="clear" symbol="gtk_cell_layout_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+        </parameters>
+      </method>
+      <method name="clear_attributes" symbol="gtk_cell_layout_clear_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_cell_layout_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="pack_end" symbol="gtk_cell_layout_pack_end">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="pack_start" symbol="gtk_cell_layout_pack_start">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="reorder" symbol="gtk_cell_layout_reorder">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_attributes" symbol="gtk_cell_layout_set_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="set_cell_data_func" symbol="gtk_cell_layout_set_cell_data_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_layout" type="GtkCellLayout*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="func" type="GtkCellLayoutDataFunc"/>
+          <parameter name="func_data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkEditable" type-name="GtkEditable">
+      <signal name="insert_text" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="position" type="gint*"/>
+        </parameters>
+      </signal>
+      <signal name="delete_text" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </signal>
+      <vfunc name="do_insert_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="position" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="do_delete_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_chars">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_selection_bounds">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_selection_bounds">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint*"/>
+          <parameter name="end_pos" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_position">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </vfunc>
+      <method name="copy_clipboard" symbol="gtk_editable_copy_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </method>
+      <method name="cut_clipboard" symbol="gtk_editable_cut_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </method>
+      <method name="delete_selection" symbol="gtk_editable_delete_selection">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </method>
+      <method name="delete_text" symbol="gtk_editable_delete_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_chars" symbol="gtk_editable_get_chars">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_editable" symbol="gtk_editable_get_editable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </method>
+      <method name="get_position" symbol="gtk_editable_get_position">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </method>
+      <method name="get_selection_bounds" symbol="gtk_editable_get_selection_bounds">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start" type="gint*"/>
+          <parameter name="end" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_editable_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert_text" symbol="gtk_editable_insert_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="new_text" type="const-gchar*"/>
+          <parameter name="new_text_length" type="gint"/>
+          <parameter name="position" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="paste_clipboard" symbol="gtk_editable_paste_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </method>
+      <method name="select_region" symbol="gtk_editable_select_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start" type="gint"/>
+          <parameter name="end" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_editable" symbol="gtk_editable_set_editable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="is_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_position" symbol="gtk_editable_set_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkFileChooser" type-name="GtkFileChooser">
+      <signal name="current_folder_changed" when="LAST"/>
+      <signal name="selection_changed" when="LAST"/>
+      <signal name="update_preview" when="LAST"/>
+      <signal name="file_activated" when="LAST"/>
+      <signal name="confirm_overwrite" when="LAST"/>
+      <property name="action" readable="1" type="GtkFileChooserAction" writable="1"/>
+      <property construct-only="1" name="file-system-backend" type="gchar*" writable="1"/>
+      <property name="filter" readable="1" type="GtkFileFilter" writable="1"/>
+      <property name="local-only" readable="1" type="gboolean" writable="1"/>
+      <property name="preview-widget" readable="1" type="GtkWidget" writable="1"/>
+      <property name="preview-widget-active" readable="1" type="gboolean" writable="1"/>
+      <property name="use-preview-label" readable="1" type="gboolean" writable="1"/>
+      <property name="extra-widget" readable="1" type="GtkWidget" writable="1"/>
+      <property name="select-multiple" readable="1" type="gboolean" writable="1"/>
+      <property name="show-hidden" readable="1" type="gboolean" writable="1"/>
+      <property name="do-overwrite-confirmation" readable="1" type="gboolean" writable="1"/>
+      <vfunc name="do_insert_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="position" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="do_delete_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_chars">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_selection_bounds">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint"/>
+          <parameter name="end_pos" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_selection_bounds">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="start_pos" type="gint*"/>
+          <parameter name="end_pos" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_position">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="editable" type="GtkEditable*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_filter" symbol="gtk_file_chooser_add_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filter" type="GtkFileFilter*"/>
+        </parameters>
+      </method>
+      <method name="add_shortcut_folder" symbol="gtk_file_chooser_add_shortcut_folder">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="folder" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="add_shortcut_folder_uri" symbol="gtk_file_chooser_add_shortcut_folder_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="uri" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="error_quark" symbol="gtk_file_chooser_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="get_action" symbol="gtk_file_chooser_get_action">
+        <return-type type="GtkFileChooserAction"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_current_folder" symbol="gtk_file_chooser_get_current_folder">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_current_folder_uri" symbol="gtk_file_chooser_get_current_folder_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_do_overwrite_confirmation" symbol="gtk_file_chooser_get_do_overwrite_confirmation">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_extra_widget" symbol="gtk_file_chooser_get_extra_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_filename" symbol="gtk_file_chooser_get_filename">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_filenames" symbol="gtk_file_chooser_get_filenames">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_filter" symbol="gtk_file_chooser_get_filter">
+        <return-type type="GtkFileFilter*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_local_only" symbol="gtk_file_chooser_get_local_only">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_preview_filename" symbol="gtk_file_chooser_get_preview_filename">
+        <return-type type="char*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_preview_uri" symbol="gtk_file_chooser_get_preview_uri">
+        <return-type type="char*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_preview_widget" symbol="gtk_file_chooser_get_preview_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_preview_widget_active" symbol="gtk_file_chooser_get_preview_widget_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_select_multiple" symbol="gtk_file_chooser_get_select_multiple">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_show_hidden" symbol="gtk_file_chooser_get_show_hidden">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_file_chooser_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uri" symbol="gtk_file_chooser_get_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_uris" symbol="gtk_file_chooser_get_uris">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_use_preview_label" symbol="gtk_file_chooser_get_use_preview_label">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="list_filters" symbol="gtk_file_chooser_list_filters">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="list_shortcut_folder_uris" symbol="gtk_file_chooser_list_shortcut_folder_uris">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="list_shortcut_folders" symbol="gtk_file_chooser_list_shortcut_folders">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="remove_filter" symbol="gtk_file_chooser_remove_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filter" type="GtkFileFilter*"/>
+        </parameters>
+      </method>
+      <method name="remove_shortcut_folder" symbol="gtk_file_chooser_remove_shortcut_folder">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="folder" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="remove_shortcut_folder_uri" symbol="gtk_file_chooser_remove_shortcut_folder_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="uri" type="const-char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="select_all" symbol="gtk_file_chooser_select_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="select_filename" symbol="gtk_file_chooser_select_filename">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filename" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="select_uri" symbol="gtk_file_chooser_select_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="uri" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="set_action" symbol="gtk_file_chooser_set_action">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="action" type="GtkFileChooserAction"/>
+        </parameters>
+      </method>
+      <method name="set_current_folder" symbol="gtk_file_chooser_set_current_folder">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_current_folder_uri" symbol="gtk_file_chooser_set_current_folder_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_current_name" symbol="gtk_file_chooser_set_current_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_do_overwrite_confirmation" symbol="gtk_file_chooser_set_do_overwrite_confirmation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="do_overwrite_confirmation" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_extra_widget" symbol="gtk_file_chooser_set_extra_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="extra_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_filename" symbol="gtk_file_chooser_set_filename">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filename" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="set_filter" symbol="gtk_file_chooser_set_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filter" type="GtkFileFilter*"/>
+        </parameters>
+      </method>
+      <method name="set_local_only" symbol="gtk_file_chooser_set_local_only">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="local_only" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_preview_widget" symbol="gtk_file_chooser_set_preview_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="preview_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_preview_widget_active" symbol="gtk_file_chooser_set_preview_widget_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="active" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_select_multiple" symbol="gtk_file_chooser_set_select_multiple">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="select_multiple" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_hidden" symbol="gtk_file_chooser_set_show_hidden">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="show_hidden" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_uri" symbol="gtk_file_chooser_set_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="uri" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="set_use_preview_label" symbol="gtk_file_chooser_set_use_preview_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="use_label" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="unselect_all" symbol="gtk_file_chooser_unselect_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+        </parameters>
+      </method>
+      <method name="unselect_filename" symbol="gtk_file_chooser_unselect_filename">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="filename" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="unselect_uri" symbol="gtk_file_chooser_unselect_uri">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkFileChooser*"/>
+          <parameter name="uri" type="const-char*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkPrintOperationPreview" type-name="GtkPrintOperationPreview">
+      <signal name="ready" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </signal>
+      <signal name="got_page_size" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+        </parameters>
+      </signal>
+      <vfunc name="render_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="page_nr" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="page_nr" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="end_preview">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+        </parameters>
+      </vfunc>
+      <method name="end_preview" symbol="gtk_print_operation_preview_end_preview">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_operation_preview_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_selected" symbol="gtk_print_operation_preview_is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="page_nr" type="gint"/>
+        </parameters>
+      </method>
+      <method name="render_page" symbol="gtk_print_operation_preview_render_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="page_nr" type="gint"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkRecentChooser" type-name="GtkRecentChooser">
+      <signal name="selection_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </signal>
+      <signal name="item_activated" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </signal>
+      <property construct-only="1" name="recent-manager" type="GtkRecentManager" writable="1"/>
+      <property name="show-private" readable="1" type="gboolean" writable="1"/>
+      <property name="show-tips" readable="1" type="gboolean" writable="1"/>
+      <property name="show-icons" readable="1" type="gboolean" writable="1"/>
+      <property name="show-not-found" readable="1" type="gboolean" writable="1"/>
+      <property name="select-multiple" readable="1" type="gboolean" writable="1"/>
+      <property name="local-only" readable="1" type="gboolean" writable="1"/>
+      <property name="limit" readable="1" type="gint" writable="1"/>
+      <property name="sort-type" readable="1" type="GtkRecentSortType" writable="1"/>
+      <property name="filter" readable="1" type="GtkRecentFilter" writable="1"/>
+      <vfunc name="set_current_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_current_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="select_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="unselect_uri">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="select_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="unselect_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_items">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_recent_manager">
+        <return-type type="GtkRecentManager*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="add_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="remove_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="list_filters">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="sort_func" type="GtkRecentSortFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </vfunc>
+      <method name="add_filter" symbol="gtk_recent_chooser_add_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </method>
+      <method name="error_quark" symbol="gtk_recent_chooser_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="get_current_item" symbol="gtk_recent_chooser_get_current_item">
+        <return-type type="GtkRecentInfo*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_current_uri" symbol="gtk_recent_chooser_get_current_uri">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_filter" symbol="gtk_recent_chooser_get_filter">
+        <return-type type="GtkRecentFilter*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_items" symbol="gtk_recent_chooser_get_items">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_limit" symbol="gtk_recent_chooser_get_limit">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_local_only" symbol="gtk_recent_chooser_get_local_only">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_select_multiple" symbol="gtk_recent_chooser_get_select_multiple">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_show_icons" symbol="gtk_recent_chooser_get_show_icons">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_show_not_found" symbol="gtk_recent_chooser_get_show_not_found">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_show_numbers" symbol="gtk_recent_chooser_get_show_numbers">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_show_private" symbol="gtk_recent_chooser_get_show_private">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_show_tips" symbol="gtk_recent_chooser_get_show_tips">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_sort_type" symbol="gtk_recent_chooser_get_sort_type">
+        <return-type type="GtkRecentSortType"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_recent_chooser_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uris" symbol="gtk_recent_chooser_get_uris">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="length" type="gsize*"/>
+        </parameters>
+      </method>
+      <method name="list_filters" symbol="gtk_recent_chooser_list_filters">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="remove_filter" symbol="gtk_recent_chooser_remove_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </method>
+      <method name="select_all" symbol="gtk_recent_chooser_select_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="select_uri" symbol="gtk_recent_chooser_select_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_current_uri" symbol="gtk_recent_chooser_set_current_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_filter" symbol="gtk_recent_chooser_set_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </method>
+      <method name="set_limit" symbol="gtk_recent_chooser_set_limit">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="limit" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_local_only" symbol="gtk_recent_chooser_set_local_only">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="local_only" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_select_multiple" symbol="gtk_recent_chooser_set_select_multiple">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="select_multiple" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_icons" symbol="gtk_recent_chooser_set_show_icons">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="show_icons" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_not_found" symbol="gtk_recent_chooser_set_show_not_found">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="show_not_found" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_numbers" symbol="gtk_recent_chooser_set_show_numbers">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="show_numbers" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_private" symbol="gtk_recent_chooser_set_show_private">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="show_private" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_tips" symbol="gtk_recent_chooser_set_show_tips">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="show_tips" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_sort_func" symbol="gtk_recent_chooser_set_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="sort_func" type="GtkRecentSortFunc"/>
+          <parameter name="sort_data" type="gpointer"/>
+          <parameter name="data_destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_sort_type" symbol="gtk_recent_chooser_set_sort_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="sort_type" type="GtkRecentSortType"/>
+        </parameters>
+      </method>
+      <method name="unselect_all" symbol="gtk_recent_chooser_unselect_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+        </parameters>
+      </method>
+      <method name="unselect_uri" symbol="gtk_recent_chooser_unselect_uri">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="chooser" type="GtkRecentChooser*"/>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkTreeDragDest" type-name="GtkTreeDragDest">
+      <vfunc name="drag_data_received">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_dest" type="GtkTreeDragDest*"/>
+          <parameter name="dest" type="GtkTreePath*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="row_drop_possible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_dest" type="GtkTreeDragDest*"/>
+          <parameter name="dest_path" type="GtkTreePath*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </vfunc>
+      <method name="drag_data_received" symbol="gtk_tree_drag_dest_drag_data_received">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_dest" type="GtkTreeDragDest*"/>
+          <parameter name="dest" type="GtkTreePath*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_drag_dest_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="row_drop_possible" symbol="gtk_tree_drag_dest_row_drop_possible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_dest" type="GtkTreeDragDest*"/>
+          <parameter name="dest_path" type="GtkTreePath*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkTreeDragSource" type-name="GtkTreeDragSource">
+      <vfunc name="row_draggable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_source" type="GtkTreeDragSource*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="drag_data_get">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_source" type="GtkTreeDragSource*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="drag_data_delete">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_source" type="GtkTreeDragSource*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </vfunc>
+      <method name="drag_data_delete" symbol="gtk_tree_drag_source_drag_data_delete">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_source" type="GtkTreeDragSource*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="drag_data_get" symbol="gtk_tree_drag_source_drag_data_get">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_source" type="GtkTreeDragSource*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_drag_source_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="row_draggable" symbol="gtk_tree_drag_source_row_draggable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="drag_source" type="GtkTreeDragSource*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkTreeModel" type-name="GtkTreeModel">
+      <signal name="row_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </signal>
+      <signal name="row_inserted" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkTreeModel*"/>
+          <parameter name="p0" type="RowInsertedParams"/>
+          <parameter name="p1" type=""/>
+        </parameters>
+      </signal>
+      <signal name="row_has_child_toggled" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </signal>
+      <signal name="row_deleted" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkTreeModel*"/>
+          <parameter name="p0" type="RowDeletedParams"/>
+        </parameters>
+      </signal>
+      <signal name="rows_reordered" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkTreeModel*"/>
+          <parameter name="p0" type="RowsReorderedParams"/>
+          <parameter name="p1" type=""/>
+          <parameter name="p2" type=""/>
+        </parameters>
+      </signal>
+      <vfunc name="row_inserted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="row_deleted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="rows_reordered">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="new_order" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_flags">
+        <return-type type="GtkTreeModelFlags"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_n_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_column_type">
+        <return-type type="GType"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_iter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="iter_next">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="iter_children">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="iter_has_child">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="iter_n_children">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="iter_nth_child">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="n" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="iter_parent">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="child" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="ref_node">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="unref_node">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </vfunc>
+      <method name="foreach" symbol="gtk_tree_model_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="model" type="GtkTreeModel*"/>
+          <parameter name="func" type="GtkTreeModelForeachFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="gtk_tree_model_get">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_column_type" symbol="gtk_tree_model_get_column_type">
+        <return-type type="GType"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_flags" symbol="gtk_tree_model_get_flags">
+        <return-type type="GtkTreeModelFlags"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+      <method name="get_iter" symbol="gtk_tree_model_get_iter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_iter_first" symbol="gtk_tree_model_get_iter_first">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_iter_from_string" symbol="gtk_tree_model_get_iter_from_string">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path_string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_n_columns" symbol="gtk_tree_model_get_n_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+      <method name="get_path" symbol="gtk_tree_model_get_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_string_from_iter" symbol="gtk_tree_model_get_string_from_iter">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_model_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_valist" symbol="gtk_tree_model_get_valist">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="var_args" type="va_list"/>
+        </parameters>
+      </method>
+      <method name="get_value" symbol="gtk_tree_model_get_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="iter_children" symbol="gtk_tree_model_iter_children">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="iter_has_child" symbol="gtk_tree_model_iter_has_child">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="iter_n_children" symbol="gtk_tree_model_iter_n_children">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="iter_next" symbol="gtk_tree_model_iter_next">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="iter_nth_child" symbol="gtk_tree_model_iter_nth_child">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="n" type="gint"/>
+        </parameters>
+      </method>
+      <method name="iter_parent" symbol="gtk_tree_model_iter_parent">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="child" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="ref_node" symbol="gtk_tree_model_ref_node">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="row_changed" symbol="gtk_tree_model_row_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="row_deleted" symbol="gtk_tree_model_row_deleted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="row_has_child_toggled" symbol="gtk_tree_model_row_has_child_toggled">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="row_inserted" symbol="gtk_tree_model_row_inserted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="rows_reordered" symbol="gtk_tree_model_rows_reordered">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="new_order" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="unref_node" symbol="gtk_tree_model_unref_node">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+    </interface>
+    <interface get-type="" name="GtkTreeSortable" type-name="GtkTreeSortable">
+      <signal name="sort_column_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_sort_column_id">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_column_id" type="gint*"/>
+          <parameter name="order" type="GtkSortType*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_sort_column_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_column_id" type="gint"/>
+          <parameter name="order" type="GtkSortType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_column_id" type="gint"/>
+          <parameter name="func" type="GtkTreeIterCompareFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_default_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="func" type="GtkTreeIterCompareFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="has_default_sort_func">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_sort_column_id" symbol="gtk_tree_sortable_get_sort_column_id">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_column_id" type="gint*"/>
+          <parameter name="order" type="GtkSortType*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_sortable_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="has_default_sort_func" symbol="gtk_tree_sortable_has_default_sort_func">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+        </parameters>
+      </method>
+      <method name="set_default_sort_func" symbol="gtk_tree_sortable_set_default_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_func" type="GtkTreeIterCompareFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_sort_column_id" symbol="gtk_tree_sortable_set_sort_column_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_column_id" type="gint"/>
+          <parameter name="order" type="GtkSortType"/>
+        </parameters>
+      </method>
+      <method name="set_sort_func" symbol="gtk_tree_sortable_set_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+          <parameter name="sort_column_id" type="gint"/>
+          <parameter name="sort_func" type="GtkTreeIterCompareFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="sort_column_changed" symbol="gtk_tree_sortable_sort_column_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="sortable" type="GtkTreeSortable*"/>
+        </parameters>
+      </method>
+    </interface>
+    <object get-type="" name="GtkAboutDialog" parent="GtkDialog" type-name="GtkAboutDialog">
+      <field name="private_data" type="gpointer"/>
+      <property name="name" readable="1" type="gchar*" writable="1"/>
+      <property name="version" readable="1" type="gchar*" writable="1"/>
+      <property name="copyright" readable="1" type="gchar*" writable="1"/>
+      <property name="comments" readable="1" type="gchar*" writable="1"/>
+      <property name="license" readable="1" type="gchar*" writable="1"/>
+      <property name="website" readable="1" type="gchar*" writable="1"/>
+      <property name="website-label" readable="1" type="gchar*" writable="1"/>
+      <property name="authors" readable="1" type="GStrv" writable="1"/>
+      <property name="documenters" readable="1" type="GStrv" writable="1"/>
+      <property name="artists" readable="1" type="GStrv" writable="1"/>
+      <property name="translator-credits" readable="1" type="gchar*" writable="1"/>
+      <property name="logo" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="logo-icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="wrap-license" readable="1" type="gboolean" writable="1"/>
+      <method name="get_artists" symbol="gtk_about_dialog_get_artists">
+        <return-type type="const-gchar**"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_authors" symbol="gtk_about_dialog_get_authors">
+        <return-type type="const-gchar**"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_comments" symbol="gtk_about_dialog_get_comments">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_copyright" symbol="gtk_about_dialog_get_copyright">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_documenters" symbol="gtk_about_dialog_get_documenters">
+        <return-type type="const-gchar**"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_license" symbol="gtk_about_dialog_get_license">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_logo" symbol="gtk_about_dialog_get_logo">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_logo_icon_name" symbol="gtk_about_dialog_get_logo_icon_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_about_dialog_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_translator_credits" symbol="gtk_about_dialog_get_translator_credits">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_about_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_version" symbol="gtk_about_dialog_get_version">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_website" symbol="gtk_about_dialog_get_website">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_website_label" symbol="gtk_about_dialog_get_website_label">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_wrap_license" symbol="gtk_about_dialog_get_wrap_license">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_about_dialog_new"/>
+      <method name="set_artists" symbol="gtk_about_dialog_set_artists">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="artists" type="const-gchar**"/>
+        </parameters>
+      </method>
+      <method name="set_authors" symbol="gtk_about_dialog_set_authors">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="authors" type="const-gchar**"/>
+        </parameters>
+      </method>
+      <method name="set_comments" symbol="gtk_about_dialog_set_comments">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="comments" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_copyright" symbol="gtk_about_dialog_set_copyright">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="copyright" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_documenters" symbol="gtk_about_dialog_set_documenters">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="documenters" type="const-gchar**"/>
+        </parameters>
+      </method>
+      <method name="set_email_hook" symbol="gtk_about_dialog_set_email_hook">
+        <return-type type="GtkAboutDialogActivateLinkFunc"/>
+        <parameters>
+          <parameter name="func" type="GtkAboutDialogActivateLinkFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_license" symbol="gtk_about_dialog_set_license">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="license" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_logo" symbol="gtk_about_dialog_set_logo">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="logo" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_logo_icon_name" symbol="gtk_about_dialog_set_logo_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_name" symbol="gtk_about_dialog_set_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_translator_credits" symbol="gtk_about_dialog_set_translator_credits">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="translator_credits" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_url_hook" symbol="gtk_about_dialog_set_url_hook">
+        <return-type type="GtkAboutDialogActivateLinkFunc"/>
+        <parameters>
+          <parameter name="func" type="GtkAboutDialogActivateLinkFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_version" symbol="gtk_about_dialog_set_version">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="version" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_website" symbol="gtk_about_dialog_set_website">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="website" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_website_label" symbol="gtk_about_dialog_set_website_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="website_label" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_wrap_license" symbol="gtk_about_dialog_set_wrap_license">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="about" type="GtkAboutDialog*"/>
+          <parameter name="wrap_license" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAccelGroup" parent="GObject" type-name="GtkAccelGroup">
+      <field name="lock_count" type="guint"/>
+      <field name="modifier_mask" type="GdkModifierType"/>
+      <field name="acceleratables" type="GSList*"/>
+      <field name="n_accels" type="guint"/>
+      <field name="priv_accels" type="GtkAccelGroupEntry*"/>
+      <signal name="accel_activate" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="inst" type="GtkAccelGroup*"/>
+          <parameter name="p0" type="GObject*"/>
+          <parameter name="p1" type="guint32"/>
+          <parameter name="p2" type="GdkModifierType"/>
+        </parameters>
+      </signal>
+      <signal name="accel_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifier" type="GdkModifierType"/>
+          <parameter name="accel_closure" type="GClosure*"/>
+        </parameters>
+      </signal>
+      <method name="activate" symbol="gtk_accel_group_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_quark" type="GQuark"/>
+          <parameter name="acceleratable" type="GObject*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="connect" symbol="gtk_accel_group_connect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+          <parameter name="accel_flags" type="GtkAccelFlags"/>
+          <parameter name="closure" type="GClosure*"/>
+        </parameters>
+      </method>
+      <method name="connect_by_path" symbol="gtk_accel_group_connect_by_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_path" type="const-gchar*"/>
+          <parameter name="closure" type="GClosure*"/>
+        </parameters>
+      </method>
+      <method name="disconnect" symbol="gtk_accel_group_disconnect">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="closure" type="GClosure*"/>
+        </parameters>
+      </method>
+      <method name="disconnect_key" symbol="gtk_accel_group_disconnect_key">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="find" symbol="gtk_accel_group_find">
+        <return-type type="GtkAccelKey*"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="find_func" type="GtkAccelGroupFindFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="from_accel_closure" symbol="gtk_accel_group_from_accel_closure">
+        <return-type type="GtkAccelGroup*"/>
+        <parameters>
+          <parameter name="closure" type="GClosure*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_accel_group_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="lock" symbol="gtk_accel_group_lock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_accel_group_new"/>
+      <method name="query" symbol="gtk_accel_group_query">
+        <return-type type="GtkAccelGroupEntry*"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+          <parameter name="n_entries" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="unlock" symbol="gtk_accel_group_unlock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAccelLabel" parent="GtkLabel" type-name="GtkAccelLabel">
+      <field name="gtk_reserved" type="guint"/>
+      <field name="accel_padding" type="guint"/>
+      <field name="accel_widget" type="GtkWidget*"/>
+      <field name="accel_closure" type="GClosure*"/>
+      <field name="accel_group" type="GtkAccelGroup*"/>
+      <field name="accel_string" type="gchar*"/>
+      <field name="accel_string_width" type="guint16"/>
+      <property name="accel-closure" readable="1" type="GClosure" writable="1"/>
+      <property name="accel-widget" readable="1" type="GtkWidget" writable="1"/>
+      <method name="get_accel_widget" symbol="gtk_accel_label_get_accel_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="accel_label" type="GtkAccelLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_accel_width" symbol="gtk_accel_label_get_accel_width">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="accel_label" type="GtkAccelLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_accel_label_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_accel_label_new">
+        <parameters>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="refetch" symbol="gtk_accel_label_refetch">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="accel_label" type="GtkAccelLabel*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_closure" symbol="gtk_accel_label_set_accel_closure">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_label" type="GtkAccelLabel*"/>
+          <parameter name="accel_closure" type="GClosure*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_widget" symbol="gtk_accel_label_set_accel_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_label" type="GtkAccelLabel*"/>
+          <parameter name="accel_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAccelMap" parent="GObject" type-name="GtkAccelMap">
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkAccelMap*"/>
+          <parameter name="p0" type="gchar*"/>
+          <parameter name="p1" type="guint32"/>
+          <parameter name="p2" type="GdkModifierType"/>
+        </parameters>
+      </signal>
+      <method name="add_entry" symbol="gtk_accel_map_add_entry">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_path" type="const-gchar*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="add_filter" symbol="gtk_accel_map_add_filter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter_pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="change_entry" symbol="gtk_accel_map_change_entry">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="accel_path" type="const-gchar*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+          <parameter name="replace" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="foreach" symbol="gtk_accel_map_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="foreach_func" type="GtkAccelMapForeach"/>
+        </parameters>
+      </method>
+      <method name="foreach_unfiltered" symbol="gtk_accel_map_foreach_unfiltered">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="foreach_func" type="GtkAccelMapForeach"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="gtk_accel_map_get">
+        <return-type type="GtkAccelMap*"/>
+      </method>
+      <method name="get_type" symbol="gtk_accel_map_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="load" symbol="gtk_accel_map_load">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="file_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="load_fd" symbol="gtk_accel_map_load_fd">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fd" type="gint"/>
+        </parameters>
+      </method>
+      <method name="load_scanner" symbol="gtk_accel_map_load_scanner">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scanner" type="GScanner*"/>
+        </parameters>
+      </method>
+      <method name="lock_path" symbol="gtk_accel_map_lock_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="lookup_entry" symbol="gtk_accel_map_lookup_entry">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="accel_path" type="const-gchar*"/>
+          <parameter name="key" type="GtkAccelKey*"/>
+        </parameters>
+      </method>
+      <method name="save" symbol="gtk_accel_map_save">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="file_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="save_fd" symbol="gtk_accel_map_save_fd">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fd" type="gint"/>
+        </parameters>
+      </method>
+      <method name="unlock_path" symbol="gtk_accel_map_unlock_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_path" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAccessible" parent="AtkObject" type-name="GtkAccessible">
+      <field name="widget" type="GtkWidget*"/>
+      <vfunc name="connect_widget_destroyed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="GtkAccessible*"/>
+        </parameters>
+      </vfunc>
+      <method name="connect_widget_destroyed" symbol="gtk_accessible_connect_widget_destroyed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accessible" type="GtkAccessible*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_accessible_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GtkAction" parent="GObject" type-name="GtkAction">
+      <field name="private_data" type="GtkActionPrivate*"/>
+      <property construct-only="1" name="name" readable="1" type="gchar*" writable="1"/>
+      <property name="label" readable="1" type="gchar*" writable="1"/>
+      <property name="short-label" readable="1" type="gchar*" writable="1"/>
+      <property name="tooltip" readable="1" type="gchar*" writable="1"/>
+      <property name="stock-id" readable="1" type="gchar*" writable="1"/>
+      <property name="icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="visible-horizontal" readable="1" type="gboolean" writable="1"/>
+      <property name="visible-overflown" readable="1" type="gboolean" writable="1"/>
+      <property name="visible-vertical" readable="1" type="gboolean" writable="1"/>
+      <property name="is-important" readable="1" type="gboolean" writable="1"/>
+      <property name="hide-if-empty" readable="1" type="gboolean" writable="1"/>
+      <property name="sensitive" readable="1" type="gboolean" writable="1"/>
+      <property name="visible" readable="1" type="gboolean" writable="1"/>
+      <property name="action-group" readable="1" type="GtkActionGroup" writable="1"/>
+      <signal name="activate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </signal>
+      <vfunc name="create_menu_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="create_tool_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="connect_proxy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="disconnect_proxy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <method name="activate" symbol="gtk_action_activate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="block_activate_from" symbol="gtk_action_block_activate_from">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="connect_accelerator" symbol="gtk_action_connect_accelerator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="connect_proxy" symbol="gtk_action_connect_proxy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="create_icon" symbol="gtk_action_create_icon">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="icon_size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="create_menu_item" symbol="gtk_action_create_menu_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="create_tool_item" symbol="gtk_action_create_tool_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="disconnect_accelerator" symbol="gtk_action_disconnect_accelerator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="disconnect_proxy" symbol="gtk_action_disconnect_proxy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_accel_closure" symbol="gtk_action_get_accel_closure">
+        <return-type type="GClosure*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="get_accel_path" symbol="gtk_action_get_accel_path">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_action_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="get_proxies" symbol="gtk_action_get_proxies">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="get_sensitive" symbol="gtk_action_get_sensitive">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_action_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible" symbol="gtk_action_get_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="is_sensitive" symbol="gtk_action_is_sensitive">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="is_visible" symbol="gtk_action_is_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_action_new">
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="label" type="const-gchar*"/>
+          <parameter name="tooltip" type="const-gchar*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_accel_group" symbol="gtk_action_set_accel_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_path" symbol="gtk_action_set_accel_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="accel_path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_sensitive" symbol="gtk_action_set_sensitive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="sensitive" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_visible" symbol="gtk_action_set_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="visible" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="unblock_activate_from" symbol="gtk_action_unblock_activate_from">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkActionGroup" parent="GObject" type-name="GtkActionGroup">
+      <field name="private_data" type="GtkActionGroupPrivate*"/>
+      <property construct-only="1" name="name" readable="1" type="gchar*" writable="1"/>
+      <property name="sensitive" readable="1" type="gboolean" writable="1"/>
+      <property name="visible" readable="1" type="gboolean" writable="1"/>
+      <signal name="connect_proxy" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkActionGroup*"/>
+          <parameter name="p0" type="GtkAction"/>
+          <parameter name="p1" type="GtkWidget"/>
+        </parameters>
+      </signal>
+      <signal name="disconnect_proxy" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkActionGroup*"/>
+          <parameter name="p0" type="GtkAction"/>
+          <parameter name="p1" type="GtkWidget"/>
+        </parameters>
+      </signal>
+      <signal name="pre_activate" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkActionGroup*"/>
+          <parameter name="p0" type="GtkAction"/>
+        </parameters>
+      </signal>
+      <signal name="post_activate" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkActionGroup*"/>
+          <parameter name="p0" type="GtkAction"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_action">
+        <return-type type="GtkAction*"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="action_name" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_action" symbol="gtk_action_group_add_action">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="add_action_with_accel" symbol="gtk_action_group_add_action_with_accel">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="accelerator" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_actions" symbol="gtk_action_group_add_actions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="entries" type="const-GtkActionEntry*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="add_actions_full" symbol="gtk_action_group_add_actions_full">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="entries" type="const-GtkActionEntry*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="add_radio_actions" symbol="gtk_action_group_add_radio_actions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="entries" type="const-GtkRadioActionEntry*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="value" type="gint"/>
+          <parameter name="on_change" type="GCallback"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="add_radio_actions_full" symbol="gtk_action_group_add_radio_actions_full">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="entries" type="const-GtkRadioActionEntry*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="value" type="gint"/>
+          <parameter name="on_change" type="GCallback"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="add_toggle_actions" symbol="gtk_action_group_add_toggle_actions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="entries" type="const-GtkToggleActionEntry*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="add_toggle_actions_full" symbol="gtk_action_group_add_toggle_actions_full">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="entries" type="const-GtkToggleActionEntry*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="get_action" symbol="gtk_action_group_get_action">
+        <return-type type="GtkAction*"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="action_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_action_group_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+        </parameters>
+      </method>
+      <method name="get_sensitive" symbol="gtk_action_group_get_sensitive">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_action_group_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible" symbol="gtk_action_group_get_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+        </parameters>
+      </method>
+      <method name="list_actions" symbol="gtk_action_group_list_actions">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_action_group_new">
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="remove_action" symbol="gtk_action_group_remove_action">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </method>
+      <method name="set_sensitive" symbol="gtk_action_group_set_sensitive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="sensitive" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_translate_func" symbol="gtk_action_group_set_translate_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="func" type="GtkTranslateFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="notify" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_translation_domain" symbol="gtk_action_group_set_translation_domain">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="domain" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_visible" symbol="gtk_action_group_set_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="visible" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="translate_string" symbol="gtk_action_group_translate_string">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAdjustment" parent="GtkObject" type-name="GtkAdjustment">
+      <field name="lower" type="gdouble"/>
+      <field name="upper" type="gdouble"/>
+      <field name="value" type="gdouble"/>
+      <field name="step_increment" type="gdouble"/>
+      <field name="page_increment" type="gdouble"/>
+      <field name="page_size" type="gdouble"/>
+      <property name="value" readable="1" type="gdouble" writable="1"/>
+      <property name="lower" readable="1" type="gdouble" writable="1"/>
+      <property name="upper" readable="1" type="gdouble" writable="1"/>
+      <property name="step-increment" readable="1" type="gdouble" writable="1"/>
+      <property name="page-increment" readable="1" type="gdouble" writable="1"/>
+      <property name="page-size" readable="1" type="gdouble" writable="1"/>
+      <signal name="changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <signal name="value_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <method name="changed" symbol="gtk_adjustment_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="clamp_page" symbol="gtk_adjustment_clamp_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+          <parameter name="lower" type="gdouble"/>
+          <parameter name="upper" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_adjustment_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_value" symbol="gtk_adjustment_get_value">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_adjustment_new">
+        <parameters>
+          <parameter name="value" type="gdouble"/>
+          <parameter name="lower" type="gdouble"/>
+          <parameter name="upper" type="gdouble"/>
+          <parameter name="step_increment" type="gdouble"/>
+          <parameter name="page_increment" type="gdouble"/>
+          <parameter name="page_size" type="gdouble"/>
+        </parameters>
+      </constructor>
+      <method name="set_value" symbol="gtk_adjustment_set_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="value_changed" symbol="gtk_adjustment_value_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAlignment" parent="GtkBin" type-name="GtkAlignment">
+      <field name="xalign" type="gfloat"/>
+      <field name="yalign" type="gfloat"/>
+      <field name="xscale" type="gfloat"/>
+      <field name="yscale" type="gfloat"/>
+      <property name="xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="yalign" readable="1" type="gfloat" writable="1"/>
+      <property name="xscale" readable="1" type="gfloat" writable="1"/>
+      <property name="yscale" readable="1" type="gfloat" writable="1"/>
+      <property name="top-padding" readable="1" type="guint" writable="1"/>
+      <property name="bottom-padding" readable="1" type="guint" writable="1"/>
+      <property name="left-padding" readable="1" type="guint" writable="1"/>
+      <property name="right-padding" readable="1" type="guint" writable="1"/>
+      <method name="get_padding" symbol="gtk_alignment_get_padding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="alignment" type="GtkAlignment*"/>
+          <parameter name="padding_top" type="guint*"/>
+          <parameter name="padding_bottom" type="guint*"/>
+          <parameter name="padding_left" type="guint*"/>
+          <parameter name="padding_right" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_alignment_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_alignment_new">
+        <parameters>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+          <parameter name="xscale" type="gfloat"/>
+          <parameter name="yscale" type="gfloat"/>
+        </parameters>
+      </constructor>
+      <method name="set" symbol="gtk_alignment_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="alignment" type="GtkAlignment*"/>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+          <parameter name="xscale" type="gfloat"/>
+          <parameter name="yscale" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_padding" symbol="gtk_alignment_set_padding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="alignment" type="GtkAlignment*"/>
+          <parameter name="padding_top" type="guint"/>
+          <parameter name="padding_bottom" type="guint"/>
+          <parameter name="padding_left" type="guint"/>
+          <parameter name="padding_right" type="guint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkArrow" parent="GtkMisc" type-name="GtkArrow">
+      <field name="arrow_type" type="gint16"/>
+      <field name="shadow_type" type="gint16"/>
+      <property name="arrow-type" readable="1" type="GtkArrowType" writable="1"/>
+      <property name="shadow-type" readable="1" type="GtkShadowType" writable="1"/>
+      <method name="get_type" symbol="gtk_arrow_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_arrow_new">
+        <parameters>
+          <parameter name="arrow_type" type="GtkArrowType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+        </parameters>
+      </constructor>
+      <method name="set" symbol="gtk_arrow_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="arrow" type="GtkArrow*"/>
+          <parameter name="arrow_type" type="GtkArrowType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAspectFrame" parent="GtkFrame" type-name="GtkAspectFrame">
+      <field name="xalign" type="gfloat"/>
+      <field name="yalign" type="gfloat"/>
+      <field name="ratio" type="gfloat"/>
+      <field name="obey_child" type="gboolean"/>
+      <field name="center_allocation" type="GtkAllocation"/>
+      <property name="xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="yalign" readable="1" type="gfloat" writable="1"/>
+      <property name="ratio" readable="1" type="gfloat" writable="1"/>
+      <property name="obey-child" readable="1" type="gboolean" writable="1"/>
+      <method name="get_type" symbol="gtk_aspect_frame_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_aspect_frame_new">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+          <parameter name="ratio" type="gfloat"/>
+          <parameter name="obey_child" type="gboolean"/>
+        </parameters>
+      </constructor>
+      <method name="set" symbol="gtk_aspect_frame_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="aspect_frame" type="GtkAspectFrame*"/>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+          <parameter name="ratio" type="gfloat"/>
+          <parameter name="obey_child" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkAssistant" parent="GtkWindow" type-name="GtkAssistant">
+      <field name="cancel" type="GtkWidget*"/>
+      <field name="forward" type="GtkWidget*"/>
+      <field name="back" type="GtkWidget*"/>
+      <field name="apply" type="GtkWidget*"/>
+      <field name="close" type="GtkWidget*"/>
+      <field name="last" type="GtkWidget*"/>
+      <field name="priv" type="GtkAssistantPrivate*"/>
+      <signal name="cancel" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+        </parameters>
+      </signal>
+      <signal name="prepare" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="apply" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+        </parameters>
+      </signal>
+      <signal name="close" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+        </parameters>
+      </signal>
+      <method name="add_action_widget" symbol="gtk_assistant_add_action_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="append_page" symbol="gtk_assistant_append_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_current_page" symbol="gtk_assistant_get_current_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+        </parameters>
+      </method>
+      <method name="get_n_pages" symbol="gtk_assistant_get_n_pages">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+        </parameters>
+      </method>
+      <method name="get_nth_page" symbol="gtk_assistant_get_nth_page">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_page_complete" symbol="gtk_assistant_get_page_complete">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_page_header_image" symbol="gtk_assistant_get_page_header_image">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_page_side_image" symbol="gtk_assistant_get_page_side_image">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_page_title" symbol="gtk_assistant_get_page_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_page_type" symbol="gtk_assistant_get_page_type">
+        <return-type type="GtkAssistantPageType"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_assistant_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert_page" symbol="gtk_assistant_insert_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_assistant_new"/>
+      <method name="prepend_page" symbol="gtk_assistant_prepend_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="remove_action_widget" symbol="gtk_assistant_remove_action_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_current_page" symbol="gtk_assistant_set_current_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_forward_page_func" symbol="gtk_assistant_set_forward_page_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page_func" type="GtkAssistantPageFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_page_complete" symbol="gtk_assistant_set_page_complete">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+          <parameter name="complete" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_page_header_image" symbol="gtk_assistant_set_page_header_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_page_side_image" symbol="gtk_assistant_set_page_side_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_page_title" symbol="gtk_assistant_set_page_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_page_type" symbol="gtk_assistant_set_page_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+          <parameter name="page" type="GtkWidget*"/>
+          <parameter name="type" type="GtkAssistantPageType"/>
+        </parameters>
+      </method>
+      <method name="update_buttons_state" symbol="gtk_assistant_update_buttons_state">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="assistant" type="GtkAssistant*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkBin" parent="GtkContainer" type-name="GtkBin">
+      <field name="child" type="GtkWidget*"/>
+      <method name="get_child" symbol="gtk_bin_get_child">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="bin" type="GtkBin*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_bin_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GtkBox" parent="GtkContainer" type-name="GtkBox">
+      <field name="children" readable="1" type="GList*" writable="1"/>
+      <field name="spacing" readable="1" type="gint16" writable="1"/>
+      <field name="homogeneous" readable="1" type="guint" writable="1"/>
+      <property name="spacing" readable="1" type="gint" writable="1"/>
+      <property name="homogeneous" readable="1" type="gboolean" writable="1"/>
+      <method name="get_homogeneous" symbol="gtk_box_get_homogeneous">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+        </parameters>
+      </method>
+      <method name="get_spacing" symbol="gtk_box_get_spacing">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="pack_end" symbol="gtk_box_pack_end">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="expand" type="gboolean"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="padding" type="guint"/>
+        </parameters>
+      </method>
+      <method name="pack_end_defaults" symbol="gtk_box_pack_end_defaults">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="pack_start" symbol="gtk_box_pack_start">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="expand" type="gboolean"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="padding" type="guint"/>
+        </parameters>
+      </method>
+      <method name="pack_start_defaults" symbol="gtk_box_pack_start_defaults">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="query_child_packing" symbol="gtk_box_query_child_packing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="expand" type="gboolean*"/>
+          <parameter name="fill" type="gboolean*"/>
+          <parameter name="padding" type="guint*"/>
+          <parameter name="pack_type" type="GtkPackType*"/>
+        </parameters>
+      </method>
+      <method name="reorder_child" symbol="gtk_box_reorder_child">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_child_packing" symbol="gtk_box_set_child_packing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="expand" type="gboolean"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="padding" type="guint"/>
+          <parameter name="pack_type" type="GtkPackType"/>
+        </parameters>
+      </method>
+      <method name="set_homogeneous" symbol="gtk_box_set_homogeneous">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="homogeneous" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_spacing" symbol="gtk_box_set_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="box" type="GtkBox*"/>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkButton" parent="GtkBin" type-name="GtkButton">
+      <field name="event_window" type="GdkWindow*"/>
+      <field name="label_text" type="gchar*"/>
+      <field name="activate_timeout" type="guint"/>
+      <field name="constructed" type="guint"/>
+      <field name="in_button" type="guint"/>
+      <field name="button_down" type="guint"/>
+      <field name="relief" type="guint"/>
+      <field name="use_underline" type="guint"/>
+      <field name="use_stock" type="guint"/>
+      <field name="depressed" type="guint"/>
+      <field name="depress_on_activate" type="guint"/>
+      <field name="focus_on_click" type="guint"/>
+      <property construct="1" name="label" readable="1" type="gchar*" writable="1"/>
+      <property construct="1" name="use-underline" readable="1" type="gboolean" writable="1"/>
+      <property construct="1" name="use-stock" readable="1" type="gboolean" writable="1"/>
+      <property name="focus-on-click" readable="1" type="gboolean" writable="1"/>
+      <property name="relief" readable="1" type="GtkReliefStyle" writable="1"/>
+      <property name="xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="yalign" readable="1" type="gfloat" writable="1"/>
+      <property name="image" readable="1" type="GtkWidget" writable="1"/>
+      <property name="image-position" readable="1" type="GtkPositionType" writable="1"/>
+      <signal name="pressed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </signal>
+      <signal name="released" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </signal>
+      <signal name="clicked" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </signal>
+      <signal name="enter" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </signal>
+      <signal name="leave" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </signal>
+      <signal name="activate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </signal>
+      <method name="action_get_type" symbol="gtk_button_action_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="clicked" symbol="gtk_button_clicked">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="enter" symbol="gtk_button_enter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_alignment" symbol="gtk_button_get_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="xalign" type="gfloat*"/>
+          <parameter name="yalign" type="gfloat*"/>
+        </parameters>
+      </method>
+      <method name="get_focus_on_click" symbol="gtk_button_get_focus_on_click">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_image" symbol="gtk_button_get_image">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_image_position" symbol="gtk_button_get_image_position">
+        <return-type type="GtkPositionType"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_label" symbol="gtk_button_get_label">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_relief" symbol="gtk_button_get_relief">
+        <return-type type="GtkReliefStyle"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_stock" symbol="gtk_button_get_use_stock">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="get_use_underline" symbol="gtk_button_get_use_underline">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="leave" symbol="gtk_button_leave">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_button_new"/>
+      <constructor name="new_from_stock" symbol="gtk_button_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label" symbol="gtk_button_new_with_label">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_button_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="pressed" symbol="gtk_button_pressed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="released" symbol="gtk_button_released">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+        </parameters>
+      </method>
+      <method name="set_alignment" symbol="gtk_button_set_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_focus_on_click" symbol="gtk_button_set_focus_on_click">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="focus_on_click" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_image" symbol="gtk_button_set_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="image" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_image_position" symbol="gtk_button_set_image_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="position" type="GtkPositionType"/>
+        </parameters>
+      </method>
+      <method name="set_label" symbol="gtk_button_set_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_relief" symbol="gtk_button_set_relief">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="newstyle" type="GtkReliefStyle"/>
+        </parameters>
+      </method>
+      <method name="set_use_stock" symbol="gtk_button_set_use_stock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="use_stock" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_use_underline" symbol="gtk_button_set_use_underline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkButton*"/>
+          <parameter name="use_underline" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkButtonBox" parent="GtkBox" type-name="GtkButtonBox">
+      <field name="child_min_width" type="gint"/>
+      <field name="child_min_height" type="gint"/>
+      <field name="child_ipad_x" type="gint"/>
+      <field name="child_ipad_y" type="gint"/>
+      <field name="layout_style" type="GtkButtonBoxStyle"/>
+      <property name="layout-style" readable="1" type="GtkButtonBoxStyle" writable="1"/>
+      <method deprecated="1" name="get_child_ipadding" symbol="gtk_button_box_get_child_ipadding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="ipad_x" type="gint*"/>
+          <parameter name="ipad_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_child_secondary" symbol="gtk_button_box_get_child_secondary">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_child_size" symbol="gtk_button_box_get_child_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="min_width" type="gint*"/>
+          <parameter name="min_height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_layout" symbol="gtk_button_box_get_layout">
+        <return-type type="GtkButtonBoxStyle"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_button_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method deprecated="1" name="set_child_ipadding" symbol="gtk_button_box_set_child_ipadding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="ipad_x" type="gint"/>
+          <parameter name="ipad_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_child_secondary" symbol="gtk_button_box_set_child_secondary">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="is_secondary" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_child_size" symbol="gtk_button_box_set_child_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="min_width" type="gint"/>
+          <parameter name="min_height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_layout" symbol="gtk_button_box_set_layout">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkButtonBox*"/>
+          <parameter name="layout_style" type="GtkButtonBoxStyle"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCalendar" parent="GtkWidget" type-name="GtkCalendar">
+      <field name="header_style" type="GtkStyle*"/>
+      <field name="label_style" type="GtkStyle*"/>
+      <field name="month" type="gint"/>
+      <field name="year" type="gint"/>
+      <field name="selected_day" type="gint"/>
+      <field name="day_month" type="gint"/>
+      <field name="day" type="gint"/>
+      <field name="num_marked_dates" type="gint"/>
+      <field name="marked_date" type="gint"/>
+      <field name="display_flags" type="GtkCalendarDisplayOptions"/>
+      <field name="marked_date_color" type="GdkColor"/>
+      <field name="gc" type="GdkGC*"/>
+      <field name="xor_gc" type="GdkGC*"/>
+      <field name="focus_row" type="gint"/>
+      <field name="focus_col" type="gint"/>
+      <field name="highlight_row" type="gint"/>
+      <field name="highlight_col" type="gint"/>
+      <field name="priv" type="GtkCalendarPrivate*"/>
+      <field name="grow_space" type="gchar"/>
+      <property name="year" readable="1" type="gint" writable="1"/>
+      <property name="month" readable="1" type="gint" writable="1"/>
+      <property name="day" readable="1" type="gint" writable="1"/>
+      <property name="show-heading" readable="1" type="gboolean" writable="1"/>
+      <property name="show-day-names" readable="1" type="gboolean" writable="1"/>
+      <property name="no-month-change" readable="1" type="gboolean" writable="1"/>
+      <property name="show-week-numbers" readable="1" type="gboolean" writable="1"/>
+      <signal name="month_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <signal name="day_selected" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <signal name="day_selected_double_click" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <signal name="prev_month" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <signal name="next_month" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <signal name="prev_year" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <signal name="next_year" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </signal>
+      <method name="clear_marks" symbol="gtk_calendar_clear_marks">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="display_options" symbol="gtk_calendar_display_options">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="flags" type="GtkCalendarDisplayOptions"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="freeze" symbol="gtk_calendar_freeze">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </method>
+      <method name="get_date" symbol="gtk_calendar_get_date">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="year" type="guint*"/>
+          <parameter name="month" type="guint*"/>
+          <parameter name="day" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="get_display_options" symbol="gtk_calendar_get_display_options">
+        <return-type type="GtkCalendarDisplayOptions"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_calendar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="mark_day" symbol="gtk_calendar_mark_day">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="day" type="guint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_calendar_new"/>
+      <method name="select_day" symbol="gtk_calendar_select_day">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="day" type="guint"/>
+        </parameters>
+      </method>
+      <method name="select_month" symbol="gtk_calendar_select_month">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="month" type="guint"/>
+          <parameter name="year" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_display_options" symbol="gtk_calendar_set_display_options">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="flags" type="GtkCalendarDisplayOptions"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="thaw" symbol="gtk_calendar_thaw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+        </parameters>
+      </method>
+      <method name="unmark_day" symbol="gtk_calendar_unmark_day">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="calendar" type="GtkCalendar*"/>
+          <parameter name="day" type="guint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCellRenderer" parent="GtkObject" type-name="GtkCellRenderer">
+      <field name="xalign" type="gfloat"/>
+      <field name="yalign" type="gfloat"/>
+      <field name="width" type="gint"/>
+      <field name="height" type="gint"/>
+      <field name="xpad" type="guint16"/>
+      <field name="ypad" type="guint16"/>
+      <field name="mode" type="guint"/>
+      <field name="visible" type="guint"/>
+      <field name="is_expander" type="guint"/>
+      <field name="is_expanded" type="guint"/>
+      <field name="cell_background_set" type="guint"/>
+      <field name="sensitive" type="guint"/>
+      <field name="editing" type="guint"/>
+      <signal name="editing_canceled" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </signal>
+      <signal name="editing_started" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="editable" type="GtkCellEditable*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <property name="mode" readable="1" type="GtkCellRendererMode" writable="1"/>
+      <property name="visible" readable="1" type="gboolean" writable="1"/>
+      <property name="sensitive" readable="1" type="gboolean" writable="1"/>
+      <property name="xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="yalign" readable="1" type="gfloat" writable="1"/>
+      <property name="xpad" readable="1" type="guint" writable="1"/>
+      <property name="ypad" readable="1" type="guint" writable="1"/>
+      <property name="width" readable="1" type="gint" writable="1"/>
+      <property name="height" readable="1" type="gint" writable="1"/>
+      <property name="is-expander" readable="1" type="gboolean" writable="1"/>
+      <property name="is-expanded" readable="1" type="gboolean" writable="1"/>
+      <property name="cell-background" type="gchar*" writable="1"/>
+      <property name="cell-background-gdk" readable="1" type="GdkColor" writable="1"/>
+      <vfunc name="get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="x_offset" type="gint*"/>
+          <parameter name="y_offset" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="render">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="window" type="GdkDrawable*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="background_area" type="GdkRectangle*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="expose_area" type="GdkRectangle*"/>
+          <parameter name="flags" type="GtkCellRendererState"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="background_area" type="GdkRectangle*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="flags" type="GtkCellRendererState"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="start_editing">
+        <return-type type="GtkCellEditable*"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="background_area" type="GdkRectangle*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="flags" type="GtkCellRendererState"/>
+        </parameters>
+      </vfunc>
+      <method name="activate" symbol="gtk_cell_renderer_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="background_area" type="GdkRectangle*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="flags" type="GtkCellRendererState"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="editing_canceled" symbol="gtk_cell_renderer_editing_canceled">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="get_fixed_size" symbol="gtk_cell_renderer_get_fixed_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gtk_cell_renderer_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="x_offset" type="gint*"/>
+          <parameter name="y_offset" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_cell_renderer_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="render" symbol="gtk_cell_renderer_render">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="background_area" type="GdkRectangle*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="expose_area" type="GdkRectangle*"/>
+          <parameter name="flags" type="GtkCellRendererState"/>
+        </parameters>
+      </method>
+      <method name="set_fixed_size" symbol="gtk_cell_renderer_set_fixed_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="start_editing" symbol="gtk_cell_renderer_start_editing">
+        <return-type type="GtkCellEditable*"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="background_area" type="GdkRectangle*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="flags" type="GtkCellRendererState"/>
+        </parameters>
+      </method>
+      <method name="stop_editing" symbol="gtk_cell_renderer_stop_editing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="canceled" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCellRendererAccel" parent="GtkCellRendererText" type-name="GtkCellRendererAccel">
+      <field name="accel_key" type="guint"/>
+      <field name="accel_mods" type="GdkModifierType"/>
+      <field name="keycode" type="guint"/>
+      <field name="accel_mode" type="GtkCellRendererAccelMode"/>
+      <field name="edit_widget" type="GtkWidget*"/>
+      <field name="grab_widget" type="GtkWidget*"/>
+      <field name="sizing_label" type="GtkWidget*"/>
+      <property name="accel-key" readable="1" type="guint" writable="1"/>
+      <property name="accel-mods" readable="1" type="GdkModifierType" writable="1"/>
+      <property name="keycode" readable="1" type="guint" writable="1"/>
+      <property name="accel-mode" readable="1" type="GtkCellRendererAccelMode" writable="1"/>
+      <signal name="accel_edited" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel" type="GtkCellRendererAccel*"/>
+          <parameter name="path_string" type="const-gchar*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+          <parameter name="hardware_keycode" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="accel_cleared" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel" type="GtkCellRendererAccel*"/>
+          <parameter name="path_string" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <method name="get_type" symbol="gtk_cell_renderer_accel_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_accel_new"/>
+    </object>
+    <object get-type="" name="GtkCellRendererCombo" parent="GtkCellRendererText" type-name="GtkCellRendererCombo">
+      <field name="model" type="GtkTreeModel*"/>
+      <field name="text_column" type="gint"/>
+      <field name="has_entry" type="gboolean"/>
+      <field name="focus_out_id" type="guint"/>
+      <property name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <property name="text-column" readable="1" type="gint" writable="1"/>
+      <property name="has-entry" readable="1" type="gboolean" writable="1"/>
+      <method name="get_type" symbol="gtk_cell_renderer_combo_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_combo_new"/>
+    </object>
+    <object get-type="" name="GtkCellRendererPixbuf" parent="GtkCellRenderer" type-name="GtkCellRendererPixbuf">
+      <field name="pixbuf" type="GdkPixbuf*"/>
+      <field name="pixbuf_expander_open" type="GdkPixbuf*"/>
+      <field name="pixbuf_expander_closed" type="GdkPixbuf*"/>
+      <property name="pixbuf" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="pixbuf-expander-open" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="pixbuf-expander-closed" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="stock-id" readable="1" type="gchar*" writable="1"/>
+      <property name="stock-size" readable="1" type="guint" writable="1"/>
+      <property name="stock-detail" readable="1" type="gchar*" writable="1"/>
+      <property name="icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="follow-state" readable="1" type="gboolean" writable="1"/>
+      <method name="get_type" symbol="gtk_cell_renderer_pixbuf_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_pixbuf_new"/>
+    </object>
+    <object get-type="" name="GtkCellRendererProgress" parent="GtkCellRenderer" type-name="GtkCellRendererProgress">
+      <field name="priv" type="GtkCellRendererProgressPrivate*"/>
+      <property name="value" readable="1" type="gint" writable="1"/>
+      <property name="text" readable="1" type="gchar*" writable="1"/>
+      <method name="get_type" symbol="gtk_cell_renderer_progress_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_progress_new"/>
+    </object>
+    <object get-type="" name="GtkCellRendererSpin" parent="GtkCellRendererText" type-name="GtkCellRendererSpin">
+      <property name="adjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="climb-rate" readable="1" type="gdouble" writable="1"/>
+      <property name="digits" readable="1" type="guint" writable="1"/>
+      <method name="get_type" symbol="gtk_cell_renderer_spin_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_spin_new"/>
+    </object>
+    <object get-type="" name="GtkCellRendererText" parent="GtkCellRenderer" type-name="GtkCellRendererText">
+      <field name="text" type="gchar*"/>
+      <field name="font" type="PangoFontDescription*"/>
+      <field name="font_scale" type="gdouble"/>
+      <field name="foreground" type="PangoColor"/>
+      <field name="background" type="PangoColor"/>
+      <field name="extra_attrs" type="PangoAttrList*"/>
+      <field name="underline_style" type="PangoUnderline"/>
+      <field name="rise" type="gint"/>
+      <field name="fixed_height_rows" type="gint"/>
+      <field name="strikethrough" type="guint"/>
+      <field name="editable" type="guint"/>
+      <field name="scale_set" type="guint"/>
+      <field name="foreground_set" type="guint"/>
+      <field name="background_set" type="guint"/>
+      <field name="underline_set" type="guint"/>
+      <field name="rise_set" type="guint"/>
+      <field name="strikethrough_set" type="guint"/>
+      <field name="editable_set" type="guint"/>
+      <field name="calc_fixed_height" type="guint"/>
+      <property name="text" readable="1" type="gchar*" writable="1"/>
+      <property name="markup" type="gchar*" writable="1"/>
+      <property name="attributes" readable="1" type="PangoAttrList" writable="1"/>
+      <property name="single-paragraph-mode" readable="1" type="gboolean" writable="1"/>
+      <property name="background" type="gchar*" writable="1"/>
+      <property name="background-gdk" readable="1" type="GdkColor" writable="1"/>
+      <property name="foreground" type="gchar*" writable="1"/>
+      <property name="foreground-gdk" readable="1" type="GdkColor" writable="1"/>
+      <property name="editable" readable="1" type="gboolean" writable="1"/>
+      <property name="font" readable="1" type="gchar*" writable="1"/>
+      <property name="font-desc" readable="1" type="PangoFontDescription" writable="1"/>
+      <property name="family" readable="1" type="gchar*" writable="1"/>
+      <property name="style" readable="1" type="PangoStyle" writable="1"/>
+      <property name="variant" readable="1" type="PangoVariant" writable="1"/>
+      <property name="weight" readable="1" type="gint" writable="1"/>
+      <property name="stretch" readable="1" type="PangoStretch" writable="1"/>
+      <property name="size" readable="1" type="gint" writable="1"/>
+      <property name="size-points" readable="1" type="gdouble" writable="1"/>
+      <property name="scale" readable="1" type="gdouble" writable="1"/>
+      <property name="rise" readable="1" type="gint" writable="1"/>
+      <property name="strikethrough" readable="1" type="gboolean" writable="1"/>
+      <property name="underline" readable="1" type="PangoUnderline" writable="1"/>
+      <property name="language" readable="1" type="gchar*" writable="1"/>
+      <property name="ellipsize" readable="1" type="PangoEllipsizeMode" writable="1"/>
+      <property name="width-chars" readable="1" type="gint" writable="1"/>
+      <property name="wrap-mode" readable="1" type="PangoWrapMode" writable="1"/>
+      <property name="wrap-width" readable="1" type="gint" writable="1"/>
+      <property name="alignment" readable="1" type="PangoAlignment" writable="1"/>
+      <signal name="edited" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_renderer_text" type="GtkCellRendererText*"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="new_text" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <method name="get_type" symbol="gtk_cell_renderer_text_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_text_new"/>
+      <method name="set_fixed_height_from_font" symbol="gtk_cell_renderer_text_set_fixed_height_from_font">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="GtkCellRendererText*"/>
+          <parameter name="number_of_rows" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCellRendererToggle" parent="GtkCellRenderer" type-name="GtkCellRendererToggle">
+      <field name="active" type="guint"/>
+      <field name="activatable" type="guint"/>
+      <field name="radio" type="guint"/>
+      <property name="active" readable="1" type="gboolean" writable="1"/>
+      <property name="inconsistent" readable="1" type="gboolean" writable="1"/>
+      <property name="activatable" readable="1" type="gboolean" writable="1"/>
+      <property name="radio" readable="1" type="gboolean" writable="1"/>
+      <property name="indicator-size" readable="1" type="gint" writable="1"/>
+      <signal name="toggled" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_renderer_toggle" type="GtkCellRendererToggle*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <method name="get_active" symbol="gtk_cell_renderer_toggle_get_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toggle" type="GtkCellRendererToggle*"/>
+        </parameters>
+      </method>
+      <method name="get_radio" symbol="gtk_cell_renderer_toggle_get_radio">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toggle" type="GtkCellRendererToggle*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_cell_renderer_toggle_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_renderer_toggle_new"/>
+      <method name="set_active" symbol="gtk_cell_renderer_toggle_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle" type="GtkCellRendererToggle*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_radio" symbol="gtk_cell_renderer_toggle_set_radio">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle" type="GtkCellRendererToggle*"/>
+          <parameter name="radio" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCellView" parent="GtkWidget" type-name="GtkCellView">
+      <field name="priv" type="GtkCellViewPrivate*"/>
+      <property name="background" type="gchar*" writable="1"/>
+      <property name="background-gdk" readable="1" type="GdkColor" writable="1"/>
+      <property name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <implements>
+        <interface name="GtkCellLayout"/>
+      </implements>
+      <method name="get_cell_renderers" symbol="gtk_cell_view_get_cell_renderers">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="cell_view" type="GtkCellView*"/>
+        </parameters>
+      </method>
+      <method name="get_displayed_row" symbol="gtk_cell_view_get_displayed_row">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="cell_view" type="GtkCellView*"/>
+        </parameters>
+      </method>
+      <method name="get_size_of_row" symbol="gtk_cell_view_get_size_of_row">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="cell_view" type="GtkCellView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="requisition" type="GtkRequisition*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_cell_view_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_cell_view_new"/>
+      <constructor name="new_with_markup" symbol="gtk_cell_view_new_with_markup">
+        <parameters>
+          <parameter name="markup" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_pixbuf" symbol="gtk_cell_view_new_with_pixbuf">
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_text" symbol="gtk_cell_view_new_with_text">
+        <parameters>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_background_color" symbol="gtk_cell_view_set_background_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_view" type="GtkCellView*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_displayed_row" symbol="gtk_cell_view_set_displayed_row">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_view" type="GtkCellView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="set_model" symbol="gtk_cell_view_set_model">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cell_view" type="GtkCellView*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCheckButton" parent="GtkToggleButton" type-name="GtkCheckButton">
+      <vfunc name="draw_indicator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_button" type="GtkCheckButton*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_type" symbol="gtk_check_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_check_button_new"/>
+      <constructor name="new_with_label" symbol="gtk_check_button_new_with_label">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_check_button_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkCheckMenuItem" parent="GtkMenuItem" type-name="GtkCheckMenuItem">
+      <field name="active" type="guint"/>
+      <field name="always_show_toggle" type="guint"/>
+      <field name="inconsistent" type="guint"/>
+      <field name="draw_as_radio" type="guint"/>
+      <property name="active" readable="1" type="gboolean" writable="1"/>
+      <property name="inconsistent" readable="1" type="gboolean" writable="1"/>
+      <property name="draw-as-radio" readable="1" type="gboolean" writable="1"/>
+      <signal name="toggled" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+        </parameters>
+      </signal>
+      <vfunc name="draw_indicator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_active" symbol="gtk_check_menu_item_get_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_draw_as_radio" symbol="gtk_check_menu_item_get_draw_as_radio">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_inconsistent" symbol="gtk_check_menu_item_get_inconsistent">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_check_menu_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_check_menu_item_new"/>
+      <constructor name="new_with_label" symbol="gtk_check_menu_item_new_with_label">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_check_menu_item_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_active" symbol="gtk_check_menu_item_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+          <parameter name="is_active" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_draw_as_radio" symbol="gtk_check_menu_item_set_draw_as_radio">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+          <parameter name="draw_as_radio" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_inconsistent" symbol="gtk_check_menu_item_set_inconsistent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_show_toggle" symbol="gtk_check_menu_item_set_show_toggle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkCheckMenuItem*"/>
+          <parameter name="always" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="toggled" symbol="gtk_check_menu_item_toggled">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="check_menu_item" type="GtkCheckMenuItem*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkClipboard" parent="GObject" type-name="GtkClipboard">
+      <signal name="owner_change" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="event" type="GdkEventOwnerChange*"/>
+        </parameters>
+      </signal>
+      <method name="clear" symbol="gtk_clipboard_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="gtk_clipboard_get">
+        <return-type type="GtkClipboard*"/>
+        <parameters>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="get_display" symbol="gtk_clipboard_get_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="get_for_display" symbol="gtk_clipboard_get_for_display">
+        <return-type type="GtkClipboard*"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="get_owner" symbol="gtk_clipboard_get_owner">
+        <return-type type="GObject*"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_clipboard_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="request_contents" symbol="gtk_clipboard_request_contents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="callback" type="GtkClipboardReceivedFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="request_image" symbol="gtk_clipboard_request_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="callback" type="GtkClipboardImageReceivedFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="request_rich_text" symbol="gtk_clipboard_request_rich_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="callback" type="GtkClipboardRichTextReceivedFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="request_targets" symbol="gtk_clipboard_request_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="callback" type="GtkClipboardTargetsReceivedFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="request_text" symbol="gtk_clipboard_request_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="callback" type="GtkClipboardTextReceivedFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="set_can_store" symbol="gtk_clipboard_set_can_store">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_image" symbol="gtk_clipboard_set_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="gtk_clipboard_set_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_with_data" symbol="gtk_clipboard_set_with_data">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="guint"/>
+          <parameter name="get_func" type="GtkClipboardGetFunc"/>
+          <parameter name="clear_func" type="GtkClipboardClearFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="set_with_owner" symbol="gtk_clipboard_set_with_owner">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="guint"/>
+          <parameter name="get_func" type="GtkClipboardGetFunc"/>
+          <parameter name="clear_func" type="GtkClipboardClearFunc"/>
+          <parameter name="owner" type="GObject*"/>
+        </parameters>
+      </method>
+      <method name="store" symbol="gtk_clipboard_store">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="wait_for_contents" symbol="gtk_clipboard_wait_for_contents">
+        <return-type type="GtkSelectionData*"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="target" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="wait_for_image" symbol="gtk_clipboard_wait_for_image">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="wait_for_rich_text" symbol="gtk_clipboard_wait_for_rich_text">
+        <return-type type="guint8*"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom*"/>
+          <parameter name="length" type="gsize*"/>
+        </parameters>
+      </method>
+      <method name="wait_for_targets" symbol="gtk_clipboard_wait_for_targets">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="targets" type="GdkAtom**"/>
+          <parameter name="n_targets" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="wait_for_text" symbol="gtk_clipboard_wait_for_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="wait_is_image_available" symbol="gtk_clipboard_wait_is_image_available">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="wait_is_rich_text_available" symbol="gtk_clipboard_wait_is_rich_text_available">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="wait_is_target_available" symbol="gtk_clipboard_wait_is_target_available">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="target" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="wait_is_text_available" symbol="gtk_clipboard_wait_is_text_available">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkColorButton" parent="GtkButton" type-name="GtkColorButton">
+      <field name="priv" type="GtkColorButtonPrivate*"/>
+      <property name="use-alpha" readable="1" type="gboolean" writable="1"/>
+      <property name="title" readable="1" type="gchar*" writable="1"/>
+      <property name="color" readable="1" type="GdkColor" writable="1"/>
+      <property name="alpha" readable="1" type="guint" writable="1"/>
+      <signal name="color_set" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cp" type="GtkColorButton*"/>
+        </parameters>
+      </signal>
+      <method name="get_alpha" symbol="gtk_color_button_get_alpha">
+        <return-type type="guint16"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+        </parameters>
+      </method>
+      <method name="get_color" symbol="gtk_color_button_get_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_color_button_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_color_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_alpha" symbol="gtk_color_button_get_use_alpha">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_color_button_new"/>
+      <constructor name="new_with_color" symbol="gtk_color_button_new_with_color">
+        <parameters>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </constructor>
+      <method name="set_alpha" symbol="gtk_color_button_set_alpha">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+          <parameter name="alpha" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="set_color" symbol="gtk_color_button_set_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_color_button_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_use_alpha" symbol="gtk_color_button_set_use_alpha">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color_button" type="GtkColorButton*"/>
+          <parameter name="use_alpha" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkColorSelection" parent="GtkVBox" type-name="GtkColorSelection">
+      <field name="private_data" type="gpointer"/>
+      <property name="has-opacity-control" readable="1" type="gboolean" writable="1"/>
+      <property name="has-palette" readable="1" type="gboolean" writable="1"/>
+      <property name="current-color" readable="1" type="GdkColor" writable="1"/>
+      <property name="current-alpha" readable="1" type="guint" writable="1"/>
+      <signal name="color_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color_selection" type="GtkColorSelection*"/>
+        </parameters>
+      </signal>
+      <method deprecated="1" name="get_color" symbol="gtk_color_selection_get_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="color" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_current_alpha" symbol="gtk_color_selection_get_current_alpha">
+        <return-type type="guint16"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_current_color" symbol="gtk_color_selection_get_current_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="get_has_opacity_control" symbol="gtk_color_selection_get_has_opacity_control">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_has_palette" symbol="gtk_color_selection_get_has_palette">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_previous_alpha" symbol="gtk_color_selection_get_previous_alpha">
+        <return-type type="guint16"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_previous_color" symbol="gtk_color_selection_get_previous_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_color_selection_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_adjusting" symbol="gtk_color_selection_is_adjusting">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_color_selection_new"/>
+      <method name="palette_from_string" symbol="gtk_color_selection_palette_from_string">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="str" type="const-gchar*"/>
+          <parameter name="colors" type="GdkColor**"/>
+          <parameter name="n_colors" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="palette_to_string" symbol="gtk_color_selection_palette_to_string">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="colors" type="const-GdkColor*"/>
+          <parameter name="n_colors" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_change_palette_hook" symbol="gtk_color_selection_set_change_palette_hook">
+        <return-type type="GtkColorSelectionChangePaletteFunc"/>
+        <parameters>
+          <parameter name="func" type="GtkColorSelectionChangePaletteFunc"/>
+        </parameters>
+      </method>
+      <method name="set_change_palette_with_screen_hook" symbol="gtk_color_selection_set_change_palette_with_screen_hook">
+        <return-type type="GtkColorSelectionChangePaletteWithScreenFunc"/>
+        <parameters>
+          <parameter name="func" type="GtkColorSelectionChangePaletteWithScreenFunc"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_color" symbol="gtk_color_selection_set_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="color" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="set_current_alpha" symbol="gtk_color_selection_set_current_alpha">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="alpha" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="set_current_color" symbol="gtk_color_selection_set_current_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="set_has_opacity_control" symbol="gtk_color_selection_set_has_opacity_control">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="has_opacity" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_has_palette" symbol="gtk_color_selection_set_has_palette">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="has_palette" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_previous_alpha" symbol="gtk_color_selection_set_previous_alpha">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="alpha" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="set_previous_color" symbol="gtk_color_selection_set_previous_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_update_policy" symbol="gtk_color_selection_set_update_policy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colorsel" type="GtkColorSelection*"/>
+          <parameter name="policy" type="GtkUpdateType"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkColorSelectionDialog" parent="GtkDialog" type-name="GtkColorSelectionDialog">
+      <field name="colorsel" type="GtkWidget*"/>
+      <field name="ok_button" type="GtkWidget*"/>
+      <field name="cancel_button" type="GtkWidget*"/>
+      <field name="help_button" type="GtkWidget*"/>
+      <method name="get_type" symbol="gtk_color_selection_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_color_selection_dialog_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object deprecated="1" get-type="" name="GtkCombo" parent="GtkHBox" type-name="GtkCombo">
+      <field name="entry" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="button" type="GtkWidget*"/>
+      <field name="popup" type="GtkWidget*"/>
+      <field name="popwin" type="GtkWidget*"/>
+      <field name="list" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="entry_change_id" type="guint"/>
+      <field name="list_change_id" type="guint"/>
+      <field name="value_in_list" type="guint"/>
+      <field name="ok_if_empty" type="guint"/>
+      <field name="case_sensitive" type="guint"/>
+      <field name="use_arrows" type="guint"/>
+      <field name="use_arrows_always" type="guint"/>
+      <field name="current_button" type="guint16"/>
+      <field name="activate_id" type="guint"/>
+      <property name="enable-arrow-keys" readable="1" type="gboolean" writable="1"/>
+      <property name="enable-arrows-always" readable="1" type="gboolean" writable="1"/>
+      <property name="case-sensitive" readable="1" type="gboolean" writable="1"/>
+      <property name="allow-empty" readable="1" type="gboolean" writable="1"/>
+      <property name="value-in-list" readable="1" type="gboolean" writable="1"/>
+      <method deprecated="1" name="disable_activate" symbol="gtk_combo_disable_activate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_type" symbol="gtk_combo_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor deprecated="1" name="new" symbol="gtk_combo_new"/>
+      <method deprecated="1" name="set_case_sensitive" symbol="gtk_combo_set_case_sensitive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+          <parameter name="val" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_item_string" symbol="gtk_combo_set_item_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+          <parameter name="item" type="GtkItem*"/>
+          <parameter name="item_value" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_popdown_strings" symbol="gtk_combo_set_popdown_strings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+          <parameter name="strings" type="GList*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_use_arrows" symbol="gtk_combo_set_use_arrows">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+          <parameter name="val" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_use_arrows_always" symbol="gtk_combo_set_use_arrows_always">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+          <parameter name="val" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_value_in_list" symbol="gtk_combo_set_value_in_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkCombo*"/>
+          <parameter name="val" type="gboolean"/>
+          <parameter name="ok_if_empty" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkComboBox" parent="GtkBin" type-name="GtkComboBox">
+      <field name="priv" type="GtkComboBoxPrivate*"/>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </signal>
+      <property name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <property name="wrap-width" readable="1" type="gint" writable="1"/>
+      <property name="row-span-column" readable="1" type="gint" writable="1"/>
+      <property name="column-span-column" readable="1" type="gint" writable="1"/>
+      <property name="active" readable="1" type="gint" writable="1"/>
+      <property name="add-tearoffs" readable="1" type="gboolean" writable="1"/>
+      <property name="has-frame" readable="1" type="gboolean" writable="1"/>
+      <property name="focus-on-click" readable="1" type="gboolean" writable="1"/>
+      <property name="tearoff-title" readable="1" type="gchar*" writable="1"/>
+      <property name="popup-shown" readable="1" type="gboolean"/>
+      <vfunc name="get_active_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </vfunc>
+      <implements>
+        <interface name="GtkCellLayout"/>
+        <interface name="GtkCellEditable"/>
+      </implements>
+      <method name="append_text" symbol="gtk_combo_box_append_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_active" symbol="gtk_combo_box_get_active">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_active_iter" symbol="gtk_combo_box_get_active_iter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_active_text" symbol="gtk_combo_box_get_active_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_add_tearoffs" symbol="gtk_combo_box_get_add_tearoffs">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_column_span_column" symbol="gtk_combo_box_get_column_span_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_focus_on_click" symbol="gtk_combo_box_get_focus_on_click">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="combo" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_combo_box_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_popup_accessible" symbol="gtk_combo_box_get_popup_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_row_separator_func" symbol="gtk_combo_box_get_row_separator_func">
+        <return-type type="GtkTreeViewRowSeparatorFunc"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_row_span_column" symbol="gtk_combo_box_get_row_span_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_combo_box_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_combo_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_wrap_width" symbol="gtk_combo_box_get_wrap_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="insert_text" symbol="gtk_combo_box_insert_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="position" type="gint"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_combo_box_new"/>
+      <constructor name="new_text" symbol="gtk_combo_box_new_text"/>
+      <constructor name="new_with_model" symbol="gtk_combo_box_new_with_model">
+        <parameters>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </constructor>
+      <method name="popdown" symbol="gtk_combo_box_popdown">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="popup" symbol="gtk_combo_box_popup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+        </parameters>
+      </method>
+      <method name="prepend_text" symbol="gtk_combo_box_prepend_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="remove_text" symbol="gtk_combo_box_remove_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_active" symbol="gtk_combo_box_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_active_iter" symbol="gtk_combo_box_set_active_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="set_add_tearoffs" symbol="gtk_combo_box_set_add_tearoffs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="add_tearoffs" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_column_span_column" symbol="gtk_combo_box_set_column_span_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="column_span" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_focus_on_click" symbol="gtk_combo_box_set_focus_on_click">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo" type="GtkComboBox*"/>
+          <parameter name="focus_on_click" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_model" symbol="gtk_combo_box_set_model">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+      <method name="set_row_separator_func" symbol="gtk_combo_box_set_row_separator_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="func" type="GtkTreeViewRowSeparatorFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_row_span_column" symbol="gtk_combo_box_set_row_span_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="row_span" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_combo_box_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_wrap_width" symbol="gtk_combo_box_set_wrap_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="combo_box" type="GtkComboBox*"/>
+          <parameter name="width" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkComboBoxEntry" parent="GtkComboBox" type-name="GtkComboBoxEntry">
+      <field name="priv" type="GtkComboBoxEntryPrivate*"/>
+      <property name="text-column" readable="1" type="gint" writable="1"/>
+      <method name="get_text_column" symbol="gtk_combo_box_entry_get_text_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="entry_box" type="GtkComboBoxEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_combo_box_entry_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_combo_box_entry_new"/>
+      <constructor name="new_text" symbol="gtk_combo_box_entry_new_text"/>
+      <constructor name="new_with_model" symbol="gtk_combo_box_entry_new_with_model">
+        <parameters>
+          <parameter name="model" type="GtkTreeModel*"/>
+          <parameter name="text_column" type="gint"/>
+        </parameters>
+      </constructor>
+      <method name="set_text_column" symbol="gtk_combo_box_entry_set_text_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry_box" type="GtkComboBoxEntry*"/>
+          <parameter name="text_column" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkContainer" parent="GtkWidget" type-name="GtkContainer">
+      <field name="focus_child" type="GtkWidget*"/>
+      <field name="border_width" type="guint"/>
+      <field name="need_resize" type="guint"/>
+      <field name="resize_mode" type="guint"/>
+      <field name="reallocate_redraws" type="guint"/>
+      <field name="has_focus_chain" type="guint"/>
+      <property name="resize-mode" readable="1" type="GtkResizeMode" writable="1"/>
+      <property name="border-width" readable="1" type="guint" writable="1"/>
+      <property name="child" type="GtkWidget" writable="1"/>
+      <signal name="add" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="remove" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="check_resize" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </signal>
+      <signal name="set_focus_child" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <vfunc name="forall">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="include_internals" type="gboolean"/>
+          <parameter name="callback" type="GtkCallback"/>
+          <parameter name="callback_data" type="gpointer"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="child_type">
+        <return-type type="GType"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="composite_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_child_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="property_id" type="guint"/>
+          <parameter name="value" type="const-GValue*"/>
+          <parameter name="pspec" type="GParamSpec*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_child_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="property_id" type="guint"/>
+          <parameter name="value" type="GValue*"/>
+          <parameter name="pspec" type="GParamSpec*"/>
+        </parameters>
+      </vfunc>
+      <method name="add" symbol="gtk_container_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="add_with_properties" symbol="gtk_container_add_with_properties">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="first_prop_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="check_resize" symbol="gtk_container_check_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="child_get" symbol="gtk_container_child_get">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="first_prop_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="child_get_property" symbol="gtk_container_child_get_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="property_name" type="const-gchar*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="child_get_valist" symbol="gtk_container_child_get_valist">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+          <parameter name="var_args" type="va_list"/>
+        </parameters>
+      </method>
+      <method name="child_set" symbol="gtk_container_child_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="first_prop_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="child_set_property" symbol="gtk_container_child_set_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="property_name" type="const-gchar*"/>
+          <parameter name="value" type="const-GValue*"/>
+        </parameters>
+      </method>
+      <method name="child_set_valist" symbol="gtk_container_child_set_valist">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+          <parameter name="var_args" type="va_list"/>
+        </parameters>
+      </method>
+      <method name="child_type" symbol="gtk_container_child_type">
+        <return-type type="GType"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="class_find_child_property" symbol="gtk_container_class_find_child_property">
+        <return-type type="GParamSpec*"/>
+        <parameters>
+          <parameter name="cclass" type="GObjectClass*"/>
+          <parameter name="property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="class_install_child_property" symbol="gtk_container_class_install_child_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cclass" type="GtkContainerClass*"/>
+          <parameter name="property_id" type="guint"/>
+          <parameter name="pspec" type="GParamSpec*"/>
+        </parameters>
+      </method>
+      <method name="class_list_child_properties" symbol="gtk_container_class_list_child_properties">
+        <return-type type="GParamSpec**"/>
+        <parameters>
+          <parameter name="cclass" type="GObjectClass*"/>
+          <parameter name="n_properties" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="forall" symbol="gtk_container_forall">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="callback" type="GtkCallback"/>
+          <parameter name="callback_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="foreach" symbol="gtk_container_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="callback" type="GtkCallback"/>
+          <parameter name="callback_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="foreach_full" symbol="gtk_container_foreach_full">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="callback" type="GtkCallback"/>
+          <parameter name="marshal" type="GtkCallbackMarshal"/>
+          <parameter name="callback_data" type="gpointer"/>
+          <parameter name="notify" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="get_border_width" symbol="gtk_container_get_border_width">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="get_children" symbol="gtk_container_get_children">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="get_focus_chain" symbol="gtk_container_get_focus_chain">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="focusable_widgets" type="GList**"/>
+        </parameters>
+      </method>
+      <method name="get_focus_hadjustment" symbol="gtk_container_get_focus_hadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="get_focus_vadjustment" symbol="gtk_container_get_focus_vadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="get_resize_mode" symbol="gtk_container_get_resize_mode">
+        <return-type type="GtkResizeMode"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_container_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="propagate_expose" symbol="gtk_container_propagate_expose">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventExpose*"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_container_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="resize_children" symbol="gtk_container_resize_children">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+      <method name="set_border_width" symbol="gtk_container_set_border_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="border_width" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_focus_chain" symbol="gtk_container_set_focus_chain">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="focusable_widgets" type="GList*"/>
+        </parameters>
+      </method>
+      <method name="set_focus_child" symbol="gtk_container_set_focus_child">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_focus_hadjustment" symbol="gtk_container_set_focus_hadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_focus_vadjustment" symbol="gtk_container_set_focus_vadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_reallocate_redraws" symbol="gtk_container_set_reallocate_redraws">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="needs_redraws" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_resize_mode" symbol="gtk_container_set_resize_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+          <parameter name="resize_mode" type="GtkResizeMode"/>
+        </parameters>
+      </method>
+      <method name="unset_focus_chain" symbol="gtk_container_unset_focus_chain">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="container" type="GtkContainer*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkCurve" parent="GtkDrawingArea" type-name="GtkCurve">
+      <field name="cursor_type" type="gint"/>
+      <field name="min_x" type="gfloat"/>
+      <field name="max_x" type="gfloat"/>
+      <field name="min_y" type="gfloat"/>
+      <field name="max_y" type="gfloat"/>
+      <field name="pixmap" type="GdkPixmap*"/>
+      <field name="curve_type" type="GtkCurveType"/>
+      <field name="height" type="gint"/>
+      <field name="grab_point" type="gint"/>
+      <field name="last" type="gint"/>
+      <field name="num_points" type="gint"/>
+      <field name="point" type="GdkPoint*"/>
+      <field name="num_ctlpoints" type="gint"/>
+      <field name="ctlpoint" type="gfloat"/>
+      <property name="curve-type" readable="1" type="GtkCurveType" writable="1"/>
+      <property name="min-x" readable="1" type="gfloat" writable="1"/>
+      <property name="max-x" readable="1" type="gfloat" writable="1"/>
+      <property name="min-y" readable="1" type="gfloat" writable="1"/>
+      <property name="max-y" readable="1" type="gfloat" writable="1"/>
+      <signal name="curve_type_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+        </parameters>
+      </signal>
+      <method name="get_type" symbol="gtk_curve_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_vector" symbol="gtk_curve_get_vector">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+          <parameter name="veclen" type="int"/>
+          <parameter name="vector" type="gfloat[]"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_curve_new"/>
+      <method name="reset" symbol="gtk_curve_reset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+        </parameters>
+      </method>
+      <method name="set_curve_type" symbol="gtk_curve_set_curve_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+          <parameter name="type" type="GtkCurveType"/>
+        </parameters>
+      </method>
+      <method name="set_gamma" symbol="gtk_curve_set_gamma">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+          <parameter name="gamma_" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_range" symbol="gtk_curve_set_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+          <parameter name="min_x" type="gfloat"/>
+          <parameter name="max_x" type="gfloat"/>
+          <parameter name="min_y" type="gfloat"/>
+          <parameter name="max_y" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_vector" symbol="gtk_curve_set_vector">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="curve" type="GtkCurve*"/>
+          <parameter name="veclen" type="int"/>
+          <parameter name="vector" type="gfloat[]"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkDialog" parent="GtkWindow" type-name="GtkDialog">
+      <field name="vbox" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="action_area" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="separator" type="GtkWidget*"/>
+      <property name="has-separator" readable="1" type="gboolean" writable="1"/>
+      <signal name="response" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="response_id" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="close" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+        </parameters>
+      </signal>
+      <method name="add_action_widget" symbol="gtk_dialog_add_action_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="response_id" type="gint"/>
+        </parameters>
+      </method>
+      <method name="add_button" symbol="gtk_dialog_add_button">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="button_text" type="const-gchar*"/>
+          <parameter name="response_id" type="gint"/>
+        </parameters>
+      </method>
+      <method name="add_buttons" symbol="gtk_dialog_add_buttons">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="first_button_text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_has_separator" symbol="gtk_dialog_get_has_separator">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_response_for_widget" symbol="gtk_dialog_get_response_for_widget">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_dialog_new"/>
+      <constructor name="new_with_buttons" symbol="gtk_dialog_new_with_buttons">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="flags" type="GtkDialogFlags"/>
+          <parameter name="first_button_text" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="response" symbol="gtk_dialog_response">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="response_id" type="gint"/>
+        </parameters>
+      </method>
+      <method name="run" symbol="gtk_dialog_run">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+        </parameters>
+      </method>
+      <method name="set_alternative_button_order" symbol="gtk_dialog_set_alternative_button_order">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="first_response_id" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_alternative_button_order_from_array" symbol="gtk_dialog_set_alternative_button_order_from_array">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="n_params" type="gint"/>
+          <parameter name="new_order" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="set_default_response" symbol="gtk_dialog_set_default_response">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="response_id" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_has_separator" symbol="gtk_dialog_set_has_separator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_response_sensitive" symbol="gtk_dialog_set_response_sensitive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkDialog*"/>
+          <parameter name="response_id" type="gint"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkDrawingArea" parent="GtkWidget" type-name="GtkDrawingArea">
+      <field name="draw_data" type="gpointer"/>
+      <method name="get_type" symbol="gtk_drawing_area_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_drawing_area_new"/>
+      <method deprecated="1" name="size" symbol="gtk_drawing_area_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="darea" type="GtkDrawingArea*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkEntry" parent="GtkWidget" type-name="GtkEntry">
+      <field name="text" type="gchar*"/>
+      <field name="editable" type="guint"/>
+      <field name="visible" type="guint"/>
+      <field name="overwrite_mode" type="guint"/>
+      <field name="in_drag" type="guint"/>
+      <field name="text_length" type="guint16"/>
+      <field name="text_max_length" type="guint16"/>
+      <field name="text_area" type="GdkWindow*"/>
+      <field name="im_context" type="GtkIMContext*"/>
+      <field name="popup_menu" type="GtkWidget*"/>
+      <field name="current_pos" type="gint"/>
+      <field name="selection_bound" type="gint"/>
+      <field name="cached_layout" type="PangoLayout*"/>
+      <field name="cache_includes_preedit" type="guint"/>
+      <field name="need_im_reset" type="guint"/>
+      <field name="has_frame" type="guint"/>
+      <field name="activates_default" type="guint"/>
+      <field name="cursor_visible" type="guint"/>
+      <field name="in_click" type="guint"/>
+      <field name="is_cell_renderer" type="guint"/>
+      <field name="editing_canceled" type="guint"/>
+      <field name="mouse_cursor_obscured" type="guint"/>
+      <field name="select_words" type="guint"/>
+      <field name="select_lines" type="guint"/>
+      <field name="resolved_dir" type="guint"/>
+      <field name="truncate_multiline" type="guint"/>
+      <field name="button" type="guint"/>
+      <field name="blink_timeout" type="guint"/>
+      <field name="recompute_idle" type="guint"/>
+      <field name="scroll_offset" type="gint"/>
+      <field name="ascent" type="gint"/>
+      <field name="descent" type="gint"/>
+      <field name="text_size" type="guint16"/>
+      <field name="n_bytes" type="guint16"/>
+      <field name="preedit_length" type="guint16"/>
+      <field name="preedit_cursor" type="guint16"/>
+      <field name="dnd_position" type="gint"/>
+      <field name="drag_start_x" type="gint"/>
+      <field name="drag_start_y" type="gint"/>
+      <field name="invisible_char" type="gunichar"/>
+      <field name="width_chars" type="gint"/>
+      <property name="cursor-position" readable="1" type="gint"/>
+      <property name="selection-bound" readable="1" type="gint"/>
+      <property name="editable" readable="1" type="gboolean" writable="1"/>
+      <property name="max-length" readable="1" type="gint" writable="1"/>
+      <property name="visibility" readable="1" type="gboolean" writable="1"/>
+      <property name="has-frame" readable="1" type="gboolean" writable="1"/>
+      <property name="inner-border" readable="1" type="GtkBorder" writable="1"/>
+      <property name="invisible-char" readable="1" type="gunichar" writable="1"/>
+      <property name="activates-default" readable="1" type="gboolean" writable="1"/>
+      <property name="width-chars" readable="1" type="gint" writable="1"/>
+      <property name="scroll-offset" readable="1" type="gint"/>
+      <property name="text" readable="1" type="gchar*" writable="1"/>
+      <property name="xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="truncate-multiline" readable="1" type="gboolean" writable="1"/>
+      <signal name="populate_popup" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </signal>
+      <signal name="activate" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </signal>
+      <signal name="move_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="step" type="GtkMovementStep"/>
+          <parameter name="count" type="gint"/>
+          <parameter name="extend_selection" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="insert_at_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <signal name="delete_from_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="type" type="GtkDeleteType"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="backspace" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </signal>
+      <signal name="cut_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </signal>
+      <signal name="copy_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </signal>
+      <signal name="paste_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_overwrite" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </signal>
+      <implements>
+        <interface name="GtkEditable"/>
+        <interface name="GtkCellEditable"/>
+      </implements>
+      <method deprecated="1" name="append_text" symbol="gtk_entry_append_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_activates_default" symbol="gtk_entry_get_activates_default">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_alignment" symbol="gtk_entry_get_alignment">
+        <return-type type="gfloat"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_completion" symbol="gtk_entry_get_completion">
+        <return-type type="GtkEntryCompletion*"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_has_frame" symbol="gtk_entry_get_has_frame">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_inner_border" symbol="gtk_entry_get_inner_border">
+        <return-type type="const-GtkBorder*"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_invisible_char" symbol="gtk_entry_get_invisible_char">
+        <return-type type="gunichar"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_layout" symbol="gtk_entry_get_layout">
+        <return-type type="PangoLayout*"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_layout_offsets" symbol="gtk_entry_get_layout_offsets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_max_length" symbol="gtk_entry_get_max_length">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="gtk_entry_get_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_entry_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visibility" symbol="gtk_entry_get_visibility">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="get_width_chars" symbol="gtk_entry_get_width_chars">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="layout_index_to_text_index" symbol="gtk_entry_layout_index_to_text_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="layout_index" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_entry_new"/>
+      <constructor deprecated="1" name="new_with_max_length" symbol="gtk_entry_new_with_max_length">
+        <parameters>
+          <parameter name="max" type="gint"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="prepend_text" symbol="gtk_entry_prepend_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="select_region" symbol="gtk_entry_select_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="start" type="gint"/>
+          <parameter name="end" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_activates_default" symbol="gtk_entry_set_activates_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_alignment" symbol="gtk_entry_set_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="xalign" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_completion" symbol="gtk_entry_set_completion">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_editable" symbol="gtk_entry_set_editable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_has_frame" symbol="gtk_entry_set_has_frame">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_inner_border" symbol="gtk_entry_set_inner_border">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="border" type="const-GtkBorder*"/>
+        </parameters>
+      </method>
+      <method name="set_invisible_char" symbol="gtk_entry_set_invisible_char">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="ch" type="gunichar"/>
+        </parameters>
+      </method>
+      <method name="set_max_length" symbol="gtk_entry_set_max_length">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="max" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_position" symbol="gtk_entry_set_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="gtk_entry_set_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_visibility" symbol="gtk_entry_set_visibility">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="visible" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_width_chars" symbol="gtk_entry_set_width_chars">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="n_chars" type="gint"/>
+        </parameters>
+      </method>
+      <method name="text_index_to_layout_index" symbol="gtk_entry_text_index_to_layout_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="entry" type="GtkEntry*"/>
+          <parameter name="text_index" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkEntryCompletion" parent="GObject" type-name="GtkEntryCompletion">
+      <field name="priv" type="GtkEntryCompletionPrivate*"/>
+      <signal name="insert_prefix" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="prefix" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <signal name="match_selected" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </signal>
+      <signal name="action_activated" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </signal>
+      <property name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <property name="minimum-key-length" readable="1" type="gint" writable="1"/>
+      <property name="text-column" readable="1" type="gint" writable="1"/>
+      <property name="inline-completion" readable="1" type="gboolean" writable="1"/>
+      <property name="popup-completion" readable="1" type="gboolean" writable="1"/>
+      <property name="popup-set-width" readable="1" type="gboolean" writable="1"/>
+      <property name="popup-single-match" readable="1" type="gboolean" writable="1"/>
+      <implements>
+        <interface name="GtkCellLayout"/>
+      </implements>
+      <method name="complete" symbol="gtk_entry_completion_complete">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="delete_action" symbol="gtk_entry_completion_delete_action">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_entry" symbol="gtk_entry_completion_get_entry">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_inline_completion" symbol="gtk_entry_completion_get_inline_completion">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_minimum_key_length" symbol="gtk_entry_completion_get_minimum_key_length">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_entry_completion_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_popup_completion" symbol="gtk_entry_completion_get_popup_completion">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_popup_set_width" symbol="gtk_entry_completion_get_popup_set_width">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_popup_single_match" symbol="gtk_entry_completion_get_popup_single_match">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_text_column" symbol="gtk_entry_completion_get_text_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_entry_completion_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert_action_markup" symbol="gtk_entry_completion_insert_action_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="index_" type="gint"/>
+          <parameter name="markup" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="insert_action_text" symbol="gtk_entry_completion_insert_action_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="index_" type="gint"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="insert_prefix" symbol="gtk_entry_completion_insert_prefix">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_entry_completion_new"/>
+      <method name="set_inline_completion" symbol="gtk_entry_completion_set_inline_completion">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="inline_completion" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_match_func" symbol="gtk_entry_completion_set_match_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="func" type="GtkEntryCompletionMatchFunc"/>
+          <parameter name="func_data" type="gpointer"/>
+          <parameter name="func_notify" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_minimum_key_length" symbol="gtk_entry_completion_set_minimum_key_length">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="length" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_model" symbol="gtk_entry_completion_set_model">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+      <method name="set_popup_completion" symbol="gtk_entry_completion_set_popup_completion">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="popup_completion" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_popup_set_width" symbol="gtk_entry_completion_set_popup_set_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="popup_set_width" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_popup_single_match" symbol="gtk_entry_completion_set_popup_single_match">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="popup_single_match" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_text_column" symbol="gtk_entry_completion_set_text_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="completion" type="GtkEntryCompletion*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkEventBox" parent="GtkBin" type-name="GtkEventBox">
+      <property name="visible-window" readable="1" type="gboolean" writable="1"/>
+      <property name="above-child" readable="1" type="gboolean" writable="1"/>
+      <method name="get_above_child" symbol="gtk_event_box_get_above_child">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event_box" type="GtkEventBox*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_event_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible_window" symbol="gtk_event_box_get_visible_window">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="event_box" type="GtkEventBox*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_event_box_new"/>
+      <method name="set_above_child" symbol="gtk_event_box_set_above_child">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event_box" type="GtkEventBox*"/>
+          <parameter name="above_child" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_visible_window" symbol="gtk_event_box_set_visible_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event_box" type="GtkEventBox*"/>
+          <parameter name="visible_window" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkExpander" parent="GtkBin" type-name="GtkExpander">
+      <field name="priv" type="GtkExpanderPrivate*"/>
+      <property construct="1" name="expanded" readable="1" type="gboolean" writable="1"/>
+      <property construct="1" name="label" readable="1" type="gchar*" writable="1"/>
+      <property construct="1" name="use-underline" readable="1" type="gboolean" writable="1"/>
+      <property construct="1" name="use-markup" readable="1" type="gboolean" writable="1"/>
+      <property name="spacing" readable="1" type="gint" writable="1"/>
+      <property name="label-widget" readable="1" type="GtkWidget" writable="1"/>
+      <signal name="activate" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </signal>
+      <method name="get_expanded" symbol="gtk_expander_get_expanded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </method>
+      <method name="get_label" symbol="gtk_expander_get_label">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </method>
+      <method name="get_label_widget" symbol="gtk_expander_get_label_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </method>
+      <method name="get_spacing" symbol="gtk_expander_get_spacing">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_expander_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_markup" symbol="gtk_expander_get_use_markup">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </method>
+      <method name="get_use_underline" symbol="gtk_expander_get_use_underline">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_expander_new">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_expander_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_expanded" symbol="gtk_expander_set_expanded">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+          <parameter name="expanded" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_label" symbol="gtk_expander_set_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_label_widget" symbol="gtk_expander_set_label_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+          <parameter name="label_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_spacing" symbol="gtk_expander_set_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_use_markup" symbol="gtk_expander_set_use_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+          <parameter name="use_markup" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_use_underline" symbol="gtk_expander_set_use_underline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="expander" type="GtkExpander*"/>
+          <parameter name="use_underline" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFileChooserButton" parent="GtkHBox" type-name="GtkFileChooserButton">
+      <field name="priv" type="GtkFileChooserButtonPrivate*"/>
+      <property construct-only="1" name="dialog" type="GtkFileChooserDialog" writable="1"/>
+      <property name="focus-on-click" readable="1" type="gboolean" writable="1"/>
+      <property name="title" readable="1" type="gchar*" writable="1"/>
+      <property name="width-chars" readable="1" type="gint" writable="1"/>
+      <implements>
+        <interface name="GtkFileChooser"/>
+      </implements>
+      <method name="get_focus_on_click" symbol="gtk_file_chooser_button_get_focus_on_click">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="button" type="GtkFileChooserButton*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_file_chooser_button_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="button" type="GtkFileChooserButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_file_chooser_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width_chars" symbol="gtk_file_chooser_button_get_width_chars">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="button" type="GtkFileChooserButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_file_chooser_button_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="action" type="GtkFileChooserAction"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_backend" symbol="gtk_file_chooser_button_new_with_backend">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="action" type="GtkFileChooserAction"/>
+          <parameter name="backend" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_dialog" symbol="gtk_file_chooser_button_new_with_dialog">
+        <parameters>
+          <parameter name="dialog" type="GtkWidget*"/>
+        </parameters>
+      </constructor>
+      <method name="set_focus_on_click" symbol="gtk_file_chooser_button_set_focus_on_click">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkFileChooserButton*"/>
+          <parameter name="focus_on_click" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_file_chooser_button_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkFileChooserButton*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_width_chars" symbol="gtk_file_chooser_button_set_width_chars">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkFileChooserButton*"/>
+          <parameter name="n_chars" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFileChooserDialog" parent="GtkDialog" type-name="GtkFileChooserDialog">
+      <field name="priv" type="GtkFileChooserDialogPrivate*"/>
+      <implements>
+        <interface name="GtkFileChooser"/>
+      </implements>
+      <method name="get_type" symbol="gtk_file_chooser_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_file_chooser_dialog_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="action" type="GtkFileChooserAction"/>
+          <parameter name="first_button_text" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_backend" symbol="gtk_file_chooser_dialog_new_with_backend">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="action" type="GtkFileChooserAction"/>
+          <parameter name="backend" type="const-gchar*"/>
+          <parameter name="first_button_text" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkFileChooserWidget" parent="GtkVBox" type-name="GtkFileChooserWidget">
+      <field name="priv" type="GtkFileChooserWidgetPrivate*"/>
+      <implements>
+        <interface name="GtkFileChooser"/>
+      </implements>
+      <method name="get_type" symbol="gtk_file_chooser_widget_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_file_chooser_widget_new">
+        <parameters>
+          <parameter name="action" type="GtkFileChooserAction"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_backend" symbol="gtk_file_chooser_widget_new_with_backend">
+        <parameters>
+          <parameter name="action" type="GtkFileChooserAction"/>
+          <parameter name="backend" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkFileFilter" parent="GtkObject" type-name="GtkFileFilter">
+      <method name="add_custom" symbol="gtk_file_filter_add_custom">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+          <parameter name="needed" type="GtkFileFilterFlags"/>
+          <parameter name="func" type="GtkFileFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="notify" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="add_mime_type" symbol="gtk_file_filter_add_mime_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_pattern" symbol="gtk_file_filter_add_pattern">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_pixbuf_formats" symbol="gtk_file_filter_add_pixbuf_formats">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+        </parameters>
+      </method>
+      <method name="filter" symbol="gtk_file_filter_filter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+          <parameter name="filter_info" type="const-GtkFileFilterInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_file_filter_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+        </parameters>
+      </method>
+      <method name="get_needed" symbol="gtk_file_filter_get_needed">
+        <return-type type="GtkFileFilterFlags"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_file_filter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_file_filter_new"/>
+      <method name="set_name" symbol="gtk_file_filter_set_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkFileFilter*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFileSelection" parent="GtkDialog" type-name="GtkFileSelection">
+      <field name="dir_list" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="file_list" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="selection_entry" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="selection_text" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="main_vbox" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="ok_button" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="cancel_button" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="help_button" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="history_pulldown" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="history_menu" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="history_list" readable="1" type="GList*" writable="1"/>
+      <field name="fileop_dialog" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="fileop_entry" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="fileop_file" readable="1" type="gchar*" writable="1"/>
+      <field name="cmpl_state" readable="1" type="gpointer" writable="1"/>
+      <field name="fileop_c_dir" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="fileop_del_file" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="fileop_ren_file" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="button_area" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="action_area" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="selected_names" type="GPtrArray*"/>
+      <field name="last_selected" type="gchar*"/>
+      <property name="filename" readable="1" type="gchar*" writable="1"/>
+      <property name="show-fileops" readable="1" type="gboolean" writable="1"/>
+      <property name="select-multiple" readable="1" type="gboolean" writable="1"/>
+      <method name="complete" symbol="gtk_file_selection_complete">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_filename" symbol="gtk_file_selection_get_filename">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_select_multiple" symbol="gtk_file_selection_get_select_multiple">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_selections" symbol="gtk_file_selection_get_selections">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_file_selection_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="hide_fileop_buttons" symbol="gtk_file_selection_hide_fileop_buttons">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_file_selection_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_filename" symbol="gtk_file_selection_set_filename">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_select_multiple" symbol="gtk_file_selection_set_select_multiple">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+          <parameter name="select_multiple" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="show_fileop_buttons" symbol="gtk_file_selection_show_fileop_buttons">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filesel" type="GtkFileSelection*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFixed" parent="GtkContainer" type-name="GtkFixed">
+      <field name="children" type="GList*"/>
+      <method name="get_has_window" symbol="gtk_fixed_get_has_window">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="fixed" type="GtkFixed*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_fixed_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="move" symbol="gtk_fixed_move">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fixed" type="GtkFixed*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_fixed_new"/>
+      <method name="put" symbol="gtk_fixed_put">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fixed" type="GtkFixed*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_has_window" symbol="gtk_fixed_set_has_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fixed" type="GtkFixed*"/>
+          <parameter name="has_window" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFontButton" parent="GtkButton" type-name="GtkFontButton">
+      <field name="priv" type="GtkFontButtonPrivate*"/>
+      <property name="title" readable="1" type="gchar*" writable="1"/>
+      <property name="font-name" readable="1" type="gchar*" writable="1"/>
+      <property name="use-font" readable="1" type="gboolean" writable="1"/>
+      <property name="use-size" readable="1" type="gboolean" writable="1"/>
+      <property name="show-style" readable="1" type="gboolean" writable="1"/>
+      <property name="show-size" readable="1" type="gboolean" writable="1"/>
+      <signal name="font_set" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gfp" type="GtkFontButton*"/>
+        </parameters>
+      </signal>
+      <method name="get_font_name" symbol="gtk_font_button_get_font_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+        </parameters>
+      </method>
+      <method name="get_show_size" symbol="gtk_font_button_get_show_size">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+        </parameters>
+      </method>
+      <method name="get_show_style" symbol="gtk_font_button_get_show_style">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_font_button_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_font_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_font" symbol="gtk_font_button_get_use_font">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+        </parameters>
+      </method>
+      <method name="get_use_size" symbol="gtk_font_button_get_use_size">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_font_button_new"/>
+      <constructor name="new_with_font" symbol="gtk_font_button_new_with_font">
+        <parameters>
+          <parameter name="fontname" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_font_name" symbol="gtk_font_button_set_font_name">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+          <parameter name="fontname" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_show_size" symbol="gtk_font_button_set_show_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+          <parameter name="show_size" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_style" symbol="gtk_font_button_set_show_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+          <parameter name="show_style" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_font_button_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_use_font" symbol="gtk_font_button_set_use_font">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+          <parameter name="use_font" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_use_size" symbol="gtk_font_button_set_use_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font_button" type="GtkFontButton*"/>
+          <parameter name="use_size" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFontSelection" parent="GtkVBox" type-name="GtkFontSelection">
+      <field name="font_entry" type="GtkWidget*"/>
+      <field name="family_list" type="GtkWidget*"/>
+      <field name="font_style_entry" type="GtkWidget*"/>
+      <field name="face_list" type="GtkWidget*"/>
+      <field name="size_entry" type="GtkWidget*"/>
+      <field name="size_list" type="GtkWidget*"/>
+      <field name="pixels_button" type="GtkWidget*"/>
+      <field name="points_button" type="GtkWidget*"/>
+      <field name="filter_button" type="GtkWidget*"/>
+      <field name="preview_entry" type="GtkWidget*"/>
+      <field name="family" type="PangoFontFamily*"/>
+      <field name="face" type="PangoFontFace*"/>
+      <field name="size" type="gint"/>
+      <field name="font" type="GdkFont*"/>
+      <property name="font-name" readable="1" type="gchar*" writable="1"/>
+      <property name="font" readable="1" type="GdkFont"/>
+      <property name="preview-text" readable="1" type="gchar*" writable="1"/>
+      <method deprecated="1" name="get_font" symbol="gtk_font_selection_get_font">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="fontsel" type="GtkFontSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_font_name" symbol="gtk_font_selection_get_font_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="fontsel" type="GtkFontSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_preview_text" symbol="gtk_font_selection_get_preview_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="fontsel" type="GtkFontSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_font_selection_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_font_selection_new"/>
+      <method name="set_font_name" symbol="gtk_font_selection_set_font_name">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="fontsel" type="GtkFontSelection*"/>
+          <parameter name="fontname" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_preview_text" symbol="gtk_font_selection_set_preview_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fontsel" type="GtkFontSelection*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFontSelectionDialog" parent="GtkDialog" type-name="GtkFontSelectionDialog">
+      <field name="fontsel" type="GtkWidget*"/>
+      <field name="main_vbox" type="GtkWidget*"/>
+      <field name="action_area" type="GtkWidget*"/>
+      <field name="ok_button" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="apply_button" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="cancel_button" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="dialog_width" type="gint"/>
+      <field name="auto_resize" type="gboolean"/>
+      <method deprecated="1" name="get_font" symbol="gtk_font_selection_dialog_get_font">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="fsd" type="GtkFontSelectionDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_font_name" symbol="gtk_font_selection_dialog_get_font_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="fsd" type="GtkFontSelectionDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_preview_text" symbol="gtk_font_selection_dialog_get_preview_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="fsd" type="GtkFontSelectionDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_font_selection_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_font_selection_dialog_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_font_name" symbol="gtk_font_selection_dialog_set_font_name">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="fsd" type="GtkFontSelectionDialog*"/>
+          <parameter name="fontname" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_preview_text" symbol="gtk_font_selection_dialog_set_preview_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fsd" type="GtkFontSelectionDialog*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkFrame" parent="GtkBin" type-name="GtkFrame">
+      <field name="label_widget" type="GtkWidget*"/>
+      <field name="shadow_type" type="gint16"/>
+      <field name="label_xalign" type="gfloat"/>
+      <field name="label_yalign" type="gfloat"/>
+      <field name="child_allocation" type="GtkAllocation"/>
+      <property name="label" readable="1" type="gchar*" writable="1"/>
+      <property name="label-xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="label-yalign" readable="1" type="gfloat" writable="1"/>
+      <property name="shadow" readable="1" type="GtkShadowType" writable="1"/>
+      <property name="shadow-type" readable="1" type="GtkShadowType" writable="1"/>
+      <property name="label-widget" readable="1" type="GtkWidget" writable="1"/>
+      <vfunc name="compute_child_allocation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+          <parameter name="allocation" type="GtkAllocation*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_label" symbol="gtk_frame_get_label">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+        </parameters>
+      </method>
+      <method name="get_label_align" symbol="gtk_frame_get_label_align">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+          <parameter name="xalign" type="gfloat*"/>
+          <parameter name="yalign" type="gfloat*"/>
+        </parameters>
+      </method>
+      <method name="get_label_widget" symbol="gtk_frame_get_label_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+        </parameters>
+      </method>
+      <method name="get_shadow_type" symbol="gtk_frame_get_shadow_type">
+        <return-type type="GtkShadowType"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_frame_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_frame_new">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_label" symbol="gtk_frame_set_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_label_align" symbol="gtk_frame_set_label_align">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_label_widget" symbol="gtk_frame_set_label_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+          <parameter name="label_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_shadow_type" symbol="gtk_frame_set_shadow_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="frame" type="GtkFrame*"/>
+          <parameter name="type" type="GtkShadowType"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkGammaCurve" parent="GtkVBox" type-name="GtkGammaCurve">
+      <field name="table" type="GtkWidget*"/>
+      <field name="curve" type="GtkWidget*"/>
+      <field name="button" type="GtkWidget*"/>
+      <field name="gamma" type="gfloat"/>
+      <field name="gamma_dialog" type="GtkWidget*"/>
+      <field name="gamma_text" type="GtkWidget*"/>
+      <method name="get_type" symbol="gtk_gamma_curve_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_gamma_curve_new"/>
+    </object>
+    <object get-type="" name="GtkHandleBox" parent="GtkBin" type-name="GtkHandleBox">
+      <field name="bin_window" type="GdkWindow*"/>
+      <field name="float_window" type="GdkWindow*"/>
+      <field name="shadow_type" type="GtkShadowType"/>
+      <field name="handle_position" type="guint"/>
+      <field name="float_window_mapped" type="guint"/>
+      <field name="child_detached" type="guint"/>
+      <field name="in_drag" type="guint"/>
+      <field name="shrink_on_detach" type="guint"/>
+      <field name="snap_edge" type="signed"/>
+      <field name="deskoff_x" type="gint"/>
+      <field name="deskoff_y" type="gint"/>
+      <field name="attach_allocation" type="GtkAllocation"/>
+      <field name="float_allocation" type="GtkAllocation"/>
+      <property name="shadow" readable="1" type="GtkShadowType" writable="1"/>
+      <property name="shadow-type" readable="1" type="GtkShadowType" writable="1"/>
+      <property name="handle-position" readable="1" type="GtkPositionType" writable="1"/>
+      <property name="snap-edge" readable="1" type="GtkPositionType" writable="1"/>
+      <property name="snap-edge-set" readable="1" type="gboolean" writable="1"/>
+      <signal name="child_attached" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="child_detached" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <method name="get_handle_position" symbol="gtk_handle_box_get_handle_position">
+        <return-type type="GtkPositionType"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+        </parameters>
+      </method>
+      <method name="get_shadow_type" symbol="gtk_handle_box_get_shadow_type">
+        <return-type type="GtkShadowType"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+        </parameters>
+      </method>
+      <method name="get_snap_edge" symbol="gtk_handle_box_get_snap_edge">
+        <return-type type="GtkPositionType"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_handle_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_handle_box_new"/>
+      <method name="set_handle_position" symbol="gtk_handle_box_set_handle_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+          <parameter name="position" type="GtkPositionType"/>
+        </parameters>
+      </method>
+      <method name="set_shadow_type" symbol="gtk_handle_box_set_shadow_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+          <parameter name="type" type="GtkShadowType"/>
+        </parameters>
+      </method>
+      <method name="set_snap_edge" symbol="gtk_handle_box_set_snap_edge">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="handle_box" type="GtkHandleBox*"/>
+          <parameter name="edge" type="GtkPositionType"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkHBox" parent="GtkBox" type-name="GtkHBox">
+      <method name="get_type" symbol="gtk_hbox_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hbox_new">
+        <parameters>
+          <parameter name="homogeneous" type="gboolean"/>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkHButtonBox" parent="GtkButtonBox" type-name="GtkHButtonBox">
+      <method deprecated="1" name="get_layout_default" symbol="gtk_hbutton_box_get_layout_default">
+        <return-type type="GtkButtonBoxStyle"/>
+      </method>
+      <method deprecated="1" name="get_spacing_default" symbol="gtk_hbutton_box_get_spacing_default">
+        <return-type type="gint"/>
+      </method>
+      <method name="get_type" symbol="gtk_hbutton_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hbutton_box_new"/>
+      <method deprecated="1" name="set_layout_default" symbol="gtk_hbutton_box_set_layout_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkButtonBoxStyle"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_spacing_default" symbol="gtk_hbutton_box_set_spacing_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkHPaned" parent="GtkPaned" type-name="GtkHPaned">
+      <method name="get_type" symbol="gtk_hpaned_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hpaned_new"/>
+    </object>
+    <object get-type="" name="GtkHRuler" parent="GtkRuler" type-name="GtkHRuler">
+      <method name="get_type" symbol="gtk_hruler_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hruler_new"/>
+    </object>
+    <object get-type="" name="GtkHScale" parent="GtkScale" type-name="GtkHScale">
+      <method name="get_type" symbol="gtk_hscale_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hscale_new">
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_range" symbol="gtk_hscale_new_with_range">
+        <parameters>
+          <parameter name="min" type="gdouble"/>
+          <parameter name="max" type="gdouble"/>
+          <parameter name="step" type="gdouble"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkHScrollbar" parent="GtkScrollbar" type-name="GtkHScrollbar">
+      <method name="get_type" symbol="gtk_hscrollbar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hscrollbar_new">
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkHSeparator" parent="GtkSeparator" type-name="GtkHSeparator">
+      <method name="get_type" symbol="gtk_hseparator_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_hseparator_new"/>
+    </object>
+    <object get-type="" name="GtkHSV" parent="GtkWidget" type-name="GtkHSV">
+      <field name="priv" type="gpointer"/>
+      <signal name="changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+        </parameters>
+      </signal>
+      <signal name="move" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+          <parameter name="type" type="GtkDirectionType"/>
+        </parameters>
+      </signal>
+      <method name="get_color" symbol="gtk_hsv_get_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+          <parameter name="h" type="gdouble*"/>
+          <parameter name="s" type="gdouble*"/>
+          <parameter name="v" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_metrics" symbol="gtk_hsv_get_metrics">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+          <parameter name="size" type="gint*"/>
+          <parameter name="ring_width" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_hsv_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_adjusting" symbol="gtk_hsv_is_adjusting">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_hsv_new"/>
+      <method name="set_color" symbol="gtk_hsv_set_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+          <parameter name="h" type="double"/>
+          <parameter name="s" type="double"/>
+          <parameter name="v" type="double"/>
+        </parameters>
+      </method>
+      <method name="set_metrics" symbol="gtk_hsv_set_metrics">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="hsv" type="GtkHSV*"/>
+          <parameter name="size" type="gint"/>
+          <parameter name="ring_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="to_rgb" symbol="gtk_hsv_to_rgb">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="h" type="gdouble"/>
+          <parameter name="s" type="gdouble"/>
+          <parameter name="v" type="gdouble"/>
+          <parameter name="r" type="gdouble*"/>
+          <parameter name="g" type="gdouble*"/>
+          <parameter name="b" type="gdouble*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkIconFactory" parent="GObject" type-name="GtkIconFactory">
+      <field name="icons" type="GHashTable*"/>
+      <method name="add" symbol="gtk_icon_factory_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="factory" type="GtkIconFactory*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+        </parameters>
+      </method>
+      <method name="add_default" symbol="gtk_icon_factory_add_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="factory" type="GtkIconFactory*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_icon_factory_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="lookup" symbol="gtk_icon_factory_lookup">
+        <return-type type="GtkIconSet*"/>
+        <parameters>
+          <parameter name="factory" type="GtkIconFactory*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="lookup_default" symbol="gtk_icon_factory_lookup_default">
+        <return-type type="GtkIconSet*"/>
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_icon_factory_new"/>
+      <method name="remove_default" symbol="gtk_icon_factory_remove_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="factory" type="GtkIconFactory*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkIconTheme" parent="GObject" type-name="GtkIconTheme">
+      <field name="priv" type="GtkIconThemePrivate*"/>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+        </parameters>
+      </signal>
+      <method name="add_builtin_icon" symbol="gtk_icon_theme_add_builtin_icon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_name" type="const-gchar*"/>
+          <parameter name="size" type="gint"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="append_search_path" symbol="gtk_icon_theme_append_search_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="error_quark" symbol="gtk_icon_theme_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="get_default" symbol="gtk_icon_theme_get_default">
+        <return-type type="GtkIconTheme*"/>
+      </method>
+      <method name="get_example_icon_name" symbol="gtk_icon_theme_get_example_icon_name">
+        <return-type type="char*"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+        </parameters>
+      </method>
+      <method name="get_for_screen" symbol="gtk_icon_theme_get_for_screen">
+        <return-type type="GtkIconTheme*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_sizes" symbol="gtk_icon_theme_get_icon_sizes">
+        <return-type type="gint*"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_search_path" symbol="gtk_icon_theme_get_search_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="path" type="gchar**[]"/>
+          <parameter name="n_elements" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_icon_theme_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="has_icon" symbol="gtk_icon_theme_has_icon">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="list_icons" symbol="gtk_icon_theme_list_icons">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="context" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="load_icon" symbol="gtk_icon_theme_load_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+          <parameter name="size" type="gint"/>
+          <parameter name="flags" type="GtkIconLookupFlags"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="lookup_icon" symbol="gtk_icon_theme_lookup_icon">
+        <return-type type="GtkIconInfo*"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+          <parameter name="size" type="gint"/>
+          <parameter name="flags" type="GtkIconLookupFlags"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_icon_theme_new"/>
+      <method name="prepend_search_path" symbol="gtk_icon_theme_prepend_search_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="rescan_if_needed" symbol="gtk_icon_theme_rescan_if_needed">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+        </parameters>
+      </method>
+      <method name="set_custom_theme" symbol="gtk_icon_theme_set_custom_theme">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="theme_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_screen" symbol="gtk_icon_theme_set_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="set_search_path" symbol="gtk_icon_theme_set_search_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_theme" type="GtkIconTheme*"/>
+          <parameter name="path" type="const-gchar*[]"/>
+          <parameter name="n_elements" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkIconView" parent="GtkContainer" type-name="GtkIconView">
+      <field name="priv" type="GtkIconViewPrivate*"/>
+      <property name="selection-mode" readable="1" type="GtkSelectionMode" writable="1"/>
+      <property name="pixbuf-column" readable="1" type="gint" writable="1"/>
+      <property name="text-column" readable="1" type="gint" writable="1"/>
+      <property name="markup-column" readable="1" type="gint" writable="1"/>
+      <property name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <property name="columns" readable="1" type="gint" writable="1"/>
+      <property name="item-width" readable="1" type="gint" writable="1"/>
+      <property name="spacing" readable="1" type="gint" writable="1"/>
+      <property name="row-spacing" readable="1" type="gint" writable="1"/>
+      <property name="column-spacing" readable="1" type="gint" writable="1"/>
+      <property name="margin" readable="1" type="gint" writable="1"/>
+      <property name="orientation" readable="1" type="GtkOrientation" writable="1"/>
+      <property name="reorderable" readable="1" type="gboolean" writable="1"/>
+      <signal name="set_scroll_adjustments" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <signal name="item_activated" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </signal>
+      <signal name="selection_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </signal>
+      <signal name="select_all" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </signal>
+      <signal name="unselect_all" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </signal>
+      <signal name="select_cursor_item" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_cursor_item" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </signal>
+      <signal name="activate_cursor_item" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </signal>
+      <signal name="move_cursor" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="step" type="GtkMovementStep"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </signal>
+      <implements>
+        <interface name="GtkCellLayout"/>
+      </implements>
+      <method name="create_drag_icon" symbol="gtk_icon_view_create_drag_icon">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="enable_model_drag_dest" symbol="gtk_icon_view_enable_model_drag_dest">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="actions" type="GdkDragAction"/>
+        </parameters>
+      </method>
+      <method name="enable_model_drag_source" symbol="gtk_icon_view_enable_model_drag_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="start_button_mask" type="GdkModifierType"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="actions" type="GdkDragAction"/>
+        </parameters>
+      </method>
+      <method name="get_column_spacing" symbol="gtk_icon_view_get_column_spacing">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_columns" symbol="gtk_icon_view_get_columns">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_cursor" symbol="gtk_icon_view_get_cursor">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="cell" type="GtkCellRenderer**"/>
+        </parameters>
+      </method>
+      <method name="get_dest_item_at_pos" symbol="gtk_icon_view_get_dest_item_at_pos">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="drag_x" type="gint"/>
+          <parameter name="drag_y" type="gint"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="pos" type="GtkIconViewDropPosition*"/>
+        </parameters>
+      </method>
+      <method name="get_drag_dest_item" symbol="gtk_icon_view_get_drag_dest_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="pos" type="GtkIconViewDropPosition*"/>
+        </parameters>
+      </method>
+      <method name="get_item_at_pos" symbol="gtk_icon_view_get_item_at_pos">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="cell" type="GtkCellRenderer**"/>
+        </parameters>
+      </method>
+      <method name="get_item_width" symbol="gtk_icon_view_get_item_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_margin" symbol="gtk_icon_view_get_margin">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_markup_column" symbol="gtk_icon_view_get_markup_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_icon_view_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_orientation" symbol="gtk_icon_view_get_orientation">
+        <return-type type="GtkOrientation"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_path_at_pos" symbol="gtk_icon_view_get_path_at_pos">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf_column" symbol="gtk_icon_view_get_pixbuf_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_reorderable" symbol="gtk_icon_view_get_reorderable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_row_spacing" symbol="gtk_icon_view_get_row_spacing">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_selected_items" symbol="gtk_icon_view_get_selected_items">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_selection_mode" symbol="gtk_icon_view_get_selection_mode">
+        <return-type type="GtkSelectionMode"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_spacing" symbol="gtk_icon_view_get_spacing">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_text_column" symbol="gtk_icon_view_get_text_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_icon_view_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible_range" symbol="gtk_icon_view_get_visible_range">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="start_path" type="GtkTreePath**"/>
+          <parameter name="end_path" type="GtkTreePath**"/>
+        </parameters>
+      </method>
+      <method name="item_activated" symbol="gtk_icon_view_item_activated">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_icon_view_new"/>
+      <constructor name="new_with_model" symbol="gtk_icon_view_new_with_model">
+        <parameters>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </constructor>
+      <method name="path_is_selected" symbol="gtk_icon_view_path_is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="scroll_to_path" symbol="gtk_icon_view_scroll_to_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="use_align" type="gboolean"/>
+          <parameter name="row_align" type="gfloat"/>
+          <parameter name="col_align" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="select_all" symbol="gtk_icon_view_select_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="select_path" symbol="gtk_icon_view_select_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="selected_foreach" symbol="gtk_icon_view_selected_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="func" type="GtkIconViewForeachFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="set_column_spacing" symbol="gtk_icon_view_set_column_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="column_spacing" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_columns" symbol="gtk_icon_view_set_columns">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="columns" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_cursor" symbol="gtk_icon_view_set_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="start_editing" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_drag_dest_item" symbol="gtk_icon_view_set_drag_dest_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="pos" type="GtkIconViewDropPosition"/>
+        </parameters>
+      </method>
+      <method name="set_item_width" symbol="gtk_icon_view_set_item_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="item_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_margin" symbol="gtk_icon_view_set_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="margin" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_markup_column" symbol="gtk_icon_view_set_markup_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_model" symbol="gtk_icon_view_set_model">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+      <method name="set_orientation" symbol="gtk_icon_view_set_orientation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </method>
+      <method name="set_pixbuf_column" symbol="gtk_icon_view_set_pixbuf_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_reorderable" symbol="gtk_icon_view_set_reorderable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="reorderable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_row_spacing" symbol="gtk_icon_view_set_row_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="row_spacing" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_selection_mode" symbol="gtk_icon_view_set_selection_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="mode" type="GtkSelectionMode"/>
+        </parameters>
+      </method>
+      <method name="set_spacing" symbol="gtk_icon_view_set_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_text_column" symbol="gtk_icon_view_set_text_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="unselect_all" symbol="gtk_icon_view_unselect_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="unselect_path" symbol="gtk_icon_view_unselect_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="unset_model_drag_dest" symbol="gtk_icon_view_unset_model_drag_dest">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+      <method name="unset_model_drag_source" symbol="gtk_icon_view_unset_model_drag_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_view" type="GtkIconView*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkImage" parent="GtkMisc" type-name="GtkImage">
+      <field name="storage_type" type="GtkImageType"/>
+      <field name="pixmap" type="union{GtkImagePixmapData"/>
+      <field name="image" type="GtkImageImageData"/>
+      <field name="pixbuf" type="GtkImagePixbufData"/>
+      <field name="stock" type="GtkImageStockData"/>
+      <field name="icon_set" type="GtkImageIconSetData"/>
+      <field name="anim" type="GtkImageAnimationData"/>
+      <field name="name" type="GtkImageIconNameData"/>
+      <field name="data" type="}"/>
+      <field name="mask" type="GdkBitmap*"/>
+      <field name="icon_size" type="GtkIconSize"/>
+      <property name="pixbuf" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="pixmap" readable="1" type="GdkPixmap" writable="1"/>
+      <property name="image" readable="1" type="GdkImage" writable="1"/>
+      <property name="mask" readable="1" type="GdkPixmap" writable="1"/>
+      <property name="file" readable="1" type="gchar*" writable="1"/>
+      <property name="stock" readable="1" type="gchar*" writable="1"/>
+      <property name="icon-set" readable="1" type="GtkIconSet" writable="1"/>
+      <property name="icon-size" readable="1" type="gint" writable="1"/>
+      <property name="pixel-size" readable="1" type="gint" writable="1"/>
+      <property name="pixbuf-animation" readable="1" type="GdkPixbufAnimation" writable="1"/>
+      <property name="icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="storage-type" readable="1" type="GtkImageType"/>
+      <method name="clear" symbol="gtk_image_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get" symbol="gtk_image_get">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="val" type="GdkImage**"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+        </parameters>
+      </method>
+      <method name="get_animation" symbol="gtk_image_get_animation">
+        <return-type type="GdkPixbufAnimation*"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_name" symbol="gtk_image_get_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter direction="out" name="icon_name" type="const-gchar**"/>
+          <parameter name="size" type="GtkIconSize*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_set" symbol="gtk_image_get_icon_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="icon_set" type="GtkIconSet**"/>
+          <parameter name="size" type="GtkIconSize*"/>
+        </parameters>
+      </method>
+      <method name="get_image" symbol="gtk_image_get_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="gdk_image" type="GdkImage**"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gtk_image_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_pixel_size" symbol="gtk_image_get_pixel_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_pixmap" symbol="gtk_image_get_pixmap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="pixmap" type="GdkPixmap**"/>
+          <parameter name="mask" type="GdkBitmap**"/>
+        </parameters>
+      </method>
+      <method name="get_stock" symbol="gtk_image_get_stock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="stock_id" type="gchar**"/>
+          <parameter name="size" type="GtkIconSize*"/>
+        </parameters>
+      </method>
+      <method name="get_storage_type" symbol="gtk_image_get_storage_type">
+        <return-type type="GtkImageType"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_image_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_image_new"/>
+      <constructor name="new_from_animation" symbol="gtk_image_new_from_animation">
+        <parameters>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_file" symbol="gtk_image_new_from_file">
+        <parameters>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_icon_name" symbol="gtk_image_new_from_icon_name">
+        <parameters>
+          <parameter name="icon_name" type="const-gchar*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_icon_set" symbol="gtk_image_new_from_icon_set">
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_image" symbol="gtk_image_new_from_image">
+        <parameters>
+          <parameter name="image" type="GdkImage*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_pixbuf" symbol="gtk_image_new_from_pixbuf">
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_pixmap" symbol="gtk_image_new_from_pixmap">
+        <parameters>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_stock" symbol="gtk_image_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="set" symbol="gtk_image_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="val" type="GdkImage*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+      <method name="set_from_animation" symbol="gtk_image_set_from_animation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="animation" type="GdkPixbufAnimation*"/>
+        </parameters>
+      </method>
+      <method name="set_from_file" symbol="gtk_image_set_from_file">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_from_icon_name" symbol="gtk_image_set_from_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="set_from_icon_set" symbol="gtk_image_set_from_icon_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="set_from_image" symbol="gtk_image_set_from_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="gdk_image" type="GdkImage*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+      <method name="set_from_pixbuf" symbol="gtk_image_set_from_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_from_pixmap" symbol="gtk_image_set_from_pixmap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+      <method name="set_from_stock" symbol="gtk_image_set_from_stock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="set_pixel_size" symbol="gtk_image_set_pixel_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image" type="GtkImage*"/>
+          <parameter name="pixel_size" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkImageMenuItem" parent="GtkMenuItem" type-name="GtkImageMenuItem">
+      <field name="image" type="GtkWidget*"/>
+      <property name="image" readable="1" type="GtkWidget" writable="1"/>
+      <method name="get_image" symbol="gtk_image_menu_item_get_image">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="image_menu_item" type="GtkImageMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_image_menu_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_image_menu_item_new"/>
+      <constructor name="new_from_stock" symbol="gtk_image_menu_item_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label" symbol="gtk_image_menu_item_new_with_label">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_image_menu_item_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_image" symbol="gtk_image_menu_item_set_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="image_menu_item" type="GtkImageMenuItem*"/>
+          <parameter name="image" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkIMContext" parent="GObject" type-name="GtkIMContext">
+      <signal name="preedit_start" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </signal>
+      <signal name="preedit_end" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </signal>
+      <signal name="preedit_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </signal>
+      <signal name="commit" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <signal name="retrieve_surrounding" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </signal>
+      <signal name="delete_surrounding" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="n_chars" type="gint"/>
+        </parameters>
+      </signal>
+      <vfunc name="set_client_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_preedit_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="str" type="gchar**"/>
+          <parameter name="attrs" type="PangoAttrList**"/>
+          <parameter name="cursor_pos" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="filter_keypress">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="focus_in">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="focus_out">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="reset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_cursor_location">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_use_preedit">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="use_preedit" type="gboolean"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_surrounding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+          <parameter name="cursor_index" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_surrounding">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="text" type="gchar**"/>
+          <parameter name="cursor_index" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <method name="delete_surrounding" symbol="gtk_im_context_delete_surrounding">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="offset" type="gint"/>
+          <parameter name="n_chars" type="gint"/>
+        </parameters>
+      </method>
+      <method name="filter_keypress" symbol="gtk_im_context_filter_keypress">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </method>
+      <method name="focus_in" symbol="gtk_im_context_focus_in">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </method>
+      <method name="focus_out" symbol="gtk_im_context_focus_out">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </method>
+      <method name="get_preedit_string" symbol="gtk_im_context_get_preedit_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="str" type="gchar**"/>
+          <parameter name="attrs" type="PangoAttrList**"/>
+          <parameter name="cursor_pos" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_surrounding" symbol="gtk_im_context_get_surrounding">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="text" type="gchar**"/>
+          <parameter name="cursor_index" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_im_context_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="reset" symbol="gtk_im_context_reset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+        </parameters>
+      </method>
+      <method name="set_client_window" symbol="gtk_im_context_set_client_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="set_cursor_location" symbol="gtk_im_context_set_cursor_location">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="set_surrounding" symbol="gtk_im_context_set_surrounding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+          <parameter name="cursor_index" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_use_preedit" symbol="gtk_im_context_set_use_preedit">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMContext*"/>
+          <parameter name="use_preedit" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkIMContextSimple" parent="GtkIMContext" type-name="GtkIMContextSimple">
+      <field name="tables" type="GSList*"/>
+      <field name="compose_buffer" type="guint"/>
+      <field name="tentative_match" type="gunichar"/>
+      <field name="tentative_match_len" type="gint"/>
+      <field name="in_hex_sequence" type="guint"/>
+      <field name="modifiers_dropped" type="guint"/>
+      <method name="add_table" symbol="gtk_im_context_simple_add_table">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context_simple" type="GtkIMContextSimple*"/>
+          <parameter name="data" type="guint16*"/>
+          <parameter name="max_seq_len" type="gint"/>
+          <parameter name="n_seqs" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_im_context_simple_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_im_context_simple_new"/>
+    </object>
+    <object get-type="" name="GtkIMMulticontext" parent="GtkIMContext" type-name="GtkIMMulticontext">
+      <field name="slave" type="GtkIMContext*"/>
+      <field name="priv" type="GtkIMMulticontextPrivate*"/>
+      <field name="context_id" type="const-gchar*"/>
+      <method name="append_menuitems" symbol="gtk_im_multicontext_append_menuitems">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkIMMulticontext*"/>
+          <parameter name="menushell" type="GtkMenuShell*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_im_multicontext_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_im_multicontext_new"/>
+    </object>
+    <object get-type="" name="GtkInputDialog" parent="GtkDialog" type-name="GtkInputDialog">
+      <field name="axis_list" type="GtkWidget*"/>
+      <field name="axis_listbox" type="GtkWidget*"/>
+      <field name="mode_optionmenu" type="GtkWidget*"/>
+      <field name="close_button" type="GtkWidget*"/>
+      <field name="save_button" type="GtkWidget*"/>
+      <field name="axis_items" type="GtkWidget*"/>
+      <field name="current_device" type="GdkDevice*"/>
+      <field name="keys_list" type="GtkWidget*"/>
+      <field name="keys_listbox" type="GtkWidget*"/>
+      <signal name="enable_device" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inputd" type="GtkInputDialog*"/>
+          <parameter name="device" type="GdkDevice*"/>
+        </parameters>
+      </signal>
+      <signal name="disable_device" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inputd" type="GtkInputDialog*"/>
+          <parameter name="device" type="GdkDevice*"/>
+        </parameters>
+      </signal>
+      <method name="get_type" symbol="gtk_input_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_input_dialog_new"/>
+    </object>
+    <object get-type="" name="GtkInvisible" parent="GtkWidget" type-name="GtkInvisible">
+      <field name="has_user_ref_count" type="gboolean"/>
+      <field name="screen" type="GdkScreen*"/>
+      <property name="screen" readable="1" type="GdkScreen" writable="1"/>
+      <method name="get_screen" symbol="gtk_invisible_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="invisible" type="GtkInvisible*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_invisible_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_invisible_new"/>
+      <constructor name="new_for_screen" symbol="gtk_invisible_new_for_screen">
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </constructor>
+      <method name="set_screen" symbol="gtk_invisible_set_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="invisible" type="GtkInvisible*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkItem" parent="GtkBin" type-name="GtkItem">
+      <signal name="select" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkItem*"/>
+        </parameters>
+      </signal>
+      <signal name="deselect" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkItem*"/>
+        </parameters>
+      </signal>
+      <signal name="toggle" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkItem*"/>
+        </parameters>
+      </signal>
+      <method name="deselect" symbol="gtk_item_deselect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkItem*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="factories_path_delete" symbol="gtk_item_factories_path_delete">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory_path" type="const-gchar*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="select" symbol="gtk_item_select">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkItem*"/>
+        </parameters>
+      </method>
+      <method name="toggle" symbol="gtk_item_toggle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkItem*"/>
+        </parameters>
+      </method>
+    </object>
+    <object deprecated="1" get-type="" name="GtkItemFactory" parent="GtkObject" type-name="GtkItemFactory">
+      <field name="path" type="gchar*"/>
+      <field name="accel_group" type="GtkAccelGroup*"/>
+      <field name="widget" type="GtkWidget*"/>
+      <field name="items" type="GSList*"/>
+      <field name="translate_func" type="GtkTranslateFunc"/>
+      <field name="translate_data" type="gpointer"/>
+      <field name="translate_notify" type="GtkDestroyNotify"/>
+      <method deprecated="1" name="add_foreign" symbol="gtk_item_factory_add_foreign">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accel_widget" type="GtkWidget*"/>
+          <parameter name="full_path" type="const-gchar*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="construct" symbol="gtk_item_factory_construct">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="container_type" type="GType"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="create_item" symbol="gtk_item_factory_create_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="entry" type="GtkItemFactoryEntry*"/>
+          <parameter name="callback_data" type="gpointer"/>
+          <parameter name="callback_type" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="create_items" symbol="gtk_item_factory_create_items">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="entries" type="GtkItemFactoryEntry*"/>
+          <parameter name="callback_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="create_items_ac" symbol="gtk_item_factory_create_items_ac">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="entries" type="GtkItemFactoryEntry*"/>
+          <parameter name="callback_data" type="gpointer"/>
+          <parameter name="callback_type" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="create_menu_entries" symbol="gtk_item_factory_create_menu_entries">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="entries" type="GtkMenuEntry*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="delete_entries" symbol="gtk_item_factory_delete_entries">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="n_entries" type="guint"/>
+          <parameter name="entries" type="GtkItemFactoryEntry*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="delete_entry" symbol="gtk_item_factory_delete_entry">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="entry" type="GtkItemFactoryEntry*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="delete_item" symbol="gtk_item_factory_delete_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="from_path" symbol="gtk_item_factory_from_path">
+        <return-type type="GtkItemFactory*"/>
+        <parameters>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="from_widget" symbol="gtk_item_factory_from_widget">
+        <return-type type="GtkItemFactory*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_item" symbol="gtk_item_factory_get_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_item_by_action" symbol="gtk_item_factory_get_item_by_action">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="action" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_type" symbol="gtk_item_factory_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method deprecated="1" name="get_widget" symbol="gtk_item_factory_get_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_widget_by_action" symbol="gtk_item_factory_get_widget_by_action">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="action" type="guint"/>
+        </parameters>
+      </method>
+      <constructor deprecated="1" name="new" symbol="gtk_item_factory_new">
+        <parameters>
+          <parameter name="container_type" type="GType"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="path_from_widget" symbol="gtk_item_factory_path_from_widget">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="popup" symbol="gtk_item_factory_popup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="x" type="guint"/>
+          <parameter name="y" type="guint"/>
+          <parameter name="mouse_button" type="guint"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="popup_data" symbol="gtk_item_factory_popup_data">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="popup_data_from_widget" symbol="gtk_item_factory_popup_data_from_widget">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="popup_with_data" symbol="gtk_item_factory_popup_with_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="popup_data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+          <parameter name="x" type="guint"/>
+          <parameter name="y" type="guint"/>
+          <parameter name="mouse_button" type="guint"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_translate_func" symbol="gtk_item_factory_set_translate_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ifactory" type="GtkItemFactory*"/>
+          <parameter name="func" type="GtkTranslateFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="notify" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkLabel" parent="GtkMisc" type-name="GtkLabel">
+      <field name="label" type="gchar*"/>
+      <field name="jtype" type="guint"/>
+      <field name="wrap" type="guint"/>
+      <field name="use_underline" type="guint"/>
+      <field name="use_markup" type="guint"/>
+      <field name="ellipsize" type="guint"/>
+      <field name="single_line_mode" type="guint"/>
+      <field name="have_transform" type="guint"/>
+      <field name="in_click" type="guint"/>
+      <field name="wrap_mode" type="guint"/>
+      <field name="mnemonic_keyval" type="guint"/>
+      <field name="text" type="gchar*"/>
+      <field name="attrs" type="PangoAttrList*"/>
+      <field name="effective_attrs" type="PangoAttrList*"/>
+      <field name="layout" type="PangoLayout*"/>
+      <field name="mnemonic_widget" type="GtkWidget*"/>
+      <field name="mnemonic_window" type="GtkWindow*"/>
+      <field name="select_info" type="GtkLabelSelectionInfo*"/>
+      <signal name="move_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="step" type="GtkMovementStep"/>
+          <parameter name="count" type="gint"/>
+          <parameter name="extend_selection" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="copy_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </signal>
+      <signal name="populate_popup" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </signal>
+      <property name="label" readable="1" type="gchar*" writable="1"/>
+      <property name="attributes" readable="1" type="PangoAttrList" writable="1"/>
+      <property name="use-markup" readable="1" type="gboolean" writable="1"/>
+      <property name="use-underline" readable="1" type="gboolean" writable="1"/>
+      <property name="justify" readable="1" type="GtkJustification" writable="1"/>
+      <property name="pattern" type="gchar*" writable="1"/>
+      <property name="wrap" readable="1" type="gboolean" writable="1"/>
+      <property name="wrap-mode" readable="1" type="PangoWrapMode" writable="1"/>
+      <property name="selectable" readable="1" type="gboolean" writable="1"/>
+      <property name="mnemonic-keyval" readable="1" type="guint"/>
+      <property name="mnemonic-widget" readable="1" type="GtkWidget" writable="1"/>
+      <property name="cursor-position" readable="1" type="gint"/>
+      <property name="selection-bound" readable="1" type="gint"/>
+      <property name="ellipsize" readable="1" type="PangoEllipsizeMode" writable="1"/>
+      <property name="width-chars" readable="1" type="gint" writable="1"/>
+      <property name="single-line-mode" readable="1" type="gboolean" writable="1"/>
+      <property name="angle" readable="1" type="gdouble" writable="1"/>
+      <property name="max-width-chars" readable="1" type="gint" writable="1"/>
+      <method deprecated="1" name="get" symbol="gtk_label_get">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="str" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="get_angle" symbol="gtk_label_get_angle">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_attributes" symbol="gtk_label_get_attributes">
+        <return-type type="PangoAttrList*"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_ellipsize" symbol="gtk_label_get_ellipsize">
+        <return-type type="PangoEllipsizeMode"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_justify" symbol="gtk_label_get_justify">
+        <return-type type="GtkJustification"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_label" symbol="gtk_label_get_label">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_layout" symbol="gtk_label_get_layout">
+        <return-type type="PangoLayout*"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_layout_offsets" symbol="gtk_label_get_layout_offsets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_line_wrap" symbol="gtk_label_get_line_wrap">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_line_wrap_mode" symbol="gtk_label_get_line_wrap_mode">
+        <return-type type="PangoWrapMode"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_max_width_chars" symbol="gtk_label_get_max_width_chars">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_mnemonic_keyval" symbol="gtk_label_get_mnemonic_keyval">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_mnemonic_widget" symbol="gtk_label_get_mnemonic_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_selectable" symbol="gtk_label_get_selectable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_selection_bounds" symbol="gtk_label_get_selection_bounds">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="start" type="gint*"/>
+          <parameter name="end" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_single_line_mode" symbol="gtk_label_get_single_line_mode">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="gtk_label_get_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_label_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_markup" symbol="gtk_label_get_use_markup">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_use_underline" symbol="gtk_label_get_use_underline">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <method name="get_width_chars" symbol="gtk_label_get_width_chars">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_label_new">
+        <parameters>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_label_new_with_mnemonic">
+        <parameters>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="parse_uline" symbol="gtk_label_parse_uline">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="select_region" symbol="gtk_label_select_region">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="start_offset" type="gint"/>
+          <parameter name="end_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_angle" symbol="gtk_label_set_angle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="angle" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_attributes" symbol="gtk_label_set_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="attrs" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+      <method name="set_ellipsize" symbol="gtk_label_set_ellipsize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="mode" type="PangoEllipsizeMode"/>
+        </parameters>
+      </method>
+      <method name="set_justify" symbol="gtk_label_set_justify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="jtype" type="GtkJustification"/>
+        </parameters>
+      </method>
+      <method name="set_label" symbol="gtk_label_set_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_line_wrap" symbol="gtk_label_set_line_wrap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="wrap" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_line_wrap_mode" symbol="gtk_label_set_line_wrap_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="wrap_mode" type="PangoWrapMode"/>
+        </parameters>
+      </method>
+      <method name="set_markup" symbol="gtk_label_set_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_markup_with_mnemonic" symbol="gtk_label_set_markup_with_mnemonic">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_max_width_chars" symbol="gtk_label_set_max_width_chars">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="n_chars" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_mnemonic_widget" symbol="gtk_label_set_mnemonic_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_pattern" symbol="gtk_label_set_pattern">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_selectable" symbol="gtk_label_set_selectable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_single_line_mode" symbol="gtk_label_set_single_line_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="single_line_mode" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="gtk_label_set_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_text_with_mnemonic" symbol="gtk_label_set_text_with_mnemonic">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_use_markup" symbol="gtk_label_set_use_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_use_underline" symbol="gtk_label_set_use_underline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_width_chars" symbol="gtk_label_set_width_chars">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="label" type="GtkLabel*"/>
+          <parameter name="n_chars" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkLayout" parent="GtkContainer" type-name="GtkLayout">
+      <field name="children" type="GList*"/>
+      <field name="width" type="guint"/>
+      <field name="height" type="guint"/>
+      <field name="hadjustment" type="GtkAdjustment*"/>
+      <field name="vadjustment" type="GtkAdjustment*"/>
+      <field name="bin_window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="visibility" type="GdkVisibilityState"/>
+      <field name="scroll_x" type="gint"/>
+      <field name="scroll_y" type="gint"/>
+      <field name="freeze_count" type="guint"/>
+      <property name="hadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="vadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="width" readable="1" type="guint" writable="1"/>
+      <property name="height" readable="1" type="guint" writable="1"/>
+      <signal name="set_scroll_adjustments" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <method deprecated="1" name="freeze" symbol="gtk_layout_freeze">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_hadjustment" symbol="gtk_layout_get_hadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gtk_layout_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="width" type="guint*"/>
+          <parameter name="height" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_layout_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_vadjustment" symbol="gtk_layout_get_vadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+        </parameters>
+      </method>
+      <method name="move" symbol="gtk_layout_move">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="child_widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_layout_new">
+        <parameters>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+      <method name="put" symbol="gtk_layout_put">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="child_widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_hadjustment" symbol="gtk_layout_set_hadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_size" symbol="gtk_layout_set_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="width" type="guint"/>
+          <parameter name="height" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_vadjustment" symbol="gtk_layout_set_vadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="thaw" symbol="gtk_layout_thaw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkLayout*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkLinkButton" parent="GtkButton" type-name="GtkLinkButton">
+      <field name="priv" type="GtkLinkButtonPrivate*"/>
+      <property name="uri" readable="1" type="gchar*" writable="1"/>
+      <vfunc name="_gtk_padding1">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="_gtk_padding2">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="_gtk_padding3">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="_gtk_padding4">
+        <return-type type="void"/>
+      </vfunc>
+      <method name="get_type" symbol="gtk_link_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uri" symbol="gtk_link_button_get_uri">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="link_button" type="GtkLinkButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_link_button_new">
+        <parameters>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label" symbol="gtk_link_button_new_with_label">
+        <parameters>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_uri" symbol="gtk_link_button_set_uri">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="link_button" type="GtkLinkButton*"/>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_uri_hook" symbol="gtk_link_button_set_uri_hook">
+        <return-type type="GtkLinkButtonUriFunc"/>
+        <parameters>
+          <parameter name="func" type="GtkLinkButtonUriFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkListStore" parent="GObject" type-name="GtkListStore">
+      <field name="stamp" type="gint"/>
+      <field name="seq" type="gpointer"/>
+      <field name="_gtk_reserved1" type="gpointer"/>
+      <field name="sort_list" type="GList*"/>
+      <field name="n_columns" type="gint"/>
+      <field name="sort_column_id" type="gint"/>
+      <field name="order" type="GtkSortType"/>
+      <field name="column_headers" type="GType*"/>
+      <field name="length" type="gint"/>
+      <field name="default_sort_func" type="GtkTreeIterCompareFunc"/>
+      <field name="default_sort_data" type="gpointer"/>
+      <field name="default_sort_destroy" type="GtkDestroyNotify"/>
+      <field name="columns_dirty" type="guint"/>
+      <implements>
+        <interface name="GtkTreeModel"/>
+        <interface name="GtkTreeDragSource"/>
+        <interface name="GtkTreeDragDest"/>
+        <interface name="GtkTreeSortable"/>
+      </implements>
+      <method name="append" symbol="gtk_list_store_append">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="clear" symbol="gtk_list_store_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_list_store_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert" symbol="gtk_list_store_insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_after" symbol="gtk_list_store_insert_after">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="sibling" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="insert_before" symbol="gtk_list_store_insert_before">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="sibling" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="insert_with_values" symbol="gtk_list_store_insert_with_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_with_valuesv" symbol="gtk_list_store_insert_with_valuesv">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="gint"/>
+          <parameter name="columns" type="gint*"/>
+          <parameter name="values" type="GValue*"/>
+          <parameter name="n_values" type="gint"/>
+        </parameters>
+      </method>
+      <method name="iter_is_valid" symbol="gtk_list_store_iter_is_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="move_after" symbol="gtk_list_store_move_after">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="move_before" symbol="gtk_list_store_move_before">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_list_store_new">
+        <parameters>
+          <parameter name="n_columns" type="gint"/>
+        </parameters>
+      </constructor>
+      <constructor name="newv" symbol="gtk_list_store_newv">
+        <parameters>
+          <parameter name="n_columns" type="gint"/>
+          <parameter name="types" type="GType*"/>
+        </parameters>
+      </constructor>
+      <method name="prepend" symbol="gtk_list_store_prepend">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_list_store_remove">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="reorder" symbol="gtk_list_store_reorder">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="store" type="GtkListStore*"/>
+          <parameter name="new_order" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="set" symbol="gtk_list_store_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="set_column_types" symbol="gtk_list_store_set_column_types">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="n_columns" type="gint"/>
+          <parameter name="types" type="GType*"/>
+        </parameters>
+      </method>
+      <method name="set_valist" symbol="gtk_list_store_set_valist">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="var_args" type="va_list"/>
+        </parameters>
+      </method>
+      <method name="set_value" symbol="gtk_list_store_set_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list_store" type="GtkListStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="swap" symbol="gtk_list_store_swap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="store" type="GtkListStore*"/>
+          <parameter name="a" type="GtkTreeIter*"/>
+          <parameter name="b" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMenu" parent="GtkMenuShell" type-name="GtkMenu">
+      <field name="parent_menu_item" type="GtkWidget*"/>
+      <field name="old_active_menu_item" type="GtkWidget*"/>
+      <field name="accel_group" type="GtkAccelGroup*"/>
+      <field name="accel_path" type="gchar*"/>
+      <field name="position_func" type="GtkMenuPositionFunc"/>
+      <field name="position_func_data" type="gpointer"/>
+      <field name="toggle_size" type="guint"/>
+      <field name="toplevel" type="GtkWidget*"/>
+      <field name="tearoff_window" type="GtkWidget*"/>
+      <field name="tearoff_hbox" type="GtkWidget*"/>
+      <field name="tearoff_scrollbar" type="GtkWidget*"/>
+      <field name="tearoff_adjustment" type="GtkAdjustment*"/>
+      <field name="view_window" type="GdkWindow*"/>
+      <field name="bin_window" type="GdkWindow*"/>
+      <field name="scroll_offset" type="gint"/>
+      <field name="saved_scroll_offset" type="gint"/>
+      <field name="scroll_step" type="gint"/>
+      <field name="timeout_id" type="guint"/>
+      <field name="navigation_region" type="GdkRegion*"/>
+      <field name="navigation_timeout" type="guint"/>
+      <field name="needs_destruction_ref_count" type="guint"/>
+      <field name="torn_off" type="guint"/>
+      <field name="tearoff_active" type="guint"/>
+      <field name="scroll_fast" type="guint"/>
+      <field name="upper_arrow_visible" type="guint"/>
+      <field name="lower_arrow_visible" type="guint"/>
+      <field name="upper_arrow_prelight" type="guint"/>
+      <field name="lower_arrow_prelight" type="guint"/>
+      <property name="tearoff-title" readable="1" type="gchar*" writable="1"/>
+      <property name="tearoff-state" readable="1" type="gboolean" writable="1"/>
+      <method name="attach" symbol="gtk_menu_attach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="left_attach" type="guint"/>
+          <parameter name="right_attach" type="guint"/>
+          <parameter name="top_attach" type="guint"/>
+          <parameter name="bottom_attach" type="guint"/>
+        </parameters>
+      </method>
+      <method name="attach_to_widget" symbol="gtk_menu_attach_to_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="attach_widget" type="GtkWidget*"/>
+          <parameter name="detacher" type="GtkMenuDetachFunc"/>
+        </parameters>
+      </method>
+      <method name="detach" symbol="gtk_menu_detach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_accel_group" symbol="gtk_menu_get_accel_group">
+        <return-type type="GtkAccelGroup*"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_active" symbol="gtk_menu_get_active">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_attach_widget" symbol="gtk_menu_get_attach_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_for_attach_widget" symbol="gtk_menu_get_for_attach_widget">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_tearoff_state" symbol="gtk_menu_get_tearoff_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_menu_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_menu_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_menu_new"/>
+      <method name="popdown" symbol="gtk_menu_popdown">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="popup" symbol="gtk_menu_popup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="parent_menu_shell" type="GtkWidget*"/>
+          <parameter name="parent_menu_item" type="GtkWidget*"/>
+          <parameter name="func" type="GtkMenuPositionFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="button" type="guint"/>
+          <parameter name="activate_time" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="reorder_child" symbol="gtk_menu_reorder_child">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="reposition" symbol="gtk_menu_reposition">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_group" symbol="gtk_menu_set_accel_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_path" symbol="gtk_menu_set_accel_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="accel_path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_active" symbol="gtk_menu_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="index_" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_monitor" symbol="gtk_menu_set_monitor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="monitor_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_screen" symbol="gtk_menu_set_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="set_tearoff_state" symbol="gtk_menu_set_tearoff_state">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="torn_off" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_menu_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMenuBar" parent="GtkMenuShell" type-name="GtkMenuBar">
+      <property name="pack-direction" readable="1" type="GtkPackDirection" writable="1"/>
+      <property name="child-pack-direction" readable="1" type="GtkPackDirection" writable="1"/>
+      <method name="get_child_pack_direction" symbol="gtk_menu_bar_get_child_pack_direction">
+        <return-type type="GtkPackDirection"/>
+        <parameters>
+          <parameter name="menubar" type="GtkMenuBar*"/>
+        </parameters>
+      </method>
+      <method name="get_pack_direction" symbol="gtk_menu_bar_get_pack_direction">
+        <return-type type="GtkPackDirection"/>
+        <parameters>
+          <parameter name="menubar" type="GtkMenuBar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_menu_bar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_menu_bar_new"/>
+      <method name="set_child_pack_direction" symbol="gtk_menu_bar_set_child_pack_direction">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menubar" type="GtkMenuBar*"/>
+          <parameter name="child_pack_dir" type="GtkPackDirection"/>
+        </parameters>
+      </method>
+      <method name="set_pack_direction" symbol="gtk_menu_bar_set_pack_direction">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menubar" type="GtkMenuBar*"/>
+          <parameter name="pack_dir" type="GtkPackDirection"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMenuItem" parent="GtkItem" type-name="GtkMenuItem">
+      <field name="submenu" type="GtkWidget*"/>
+      <field name="event_window" type="GdkWindow*"/>
+      <field name="toggle_size" type="guint16"/>
+      <field name="accelerator_width" type="guint16"/>
+      <field name="accel_path" type="gchar*"/>
+      <field name="show_submenu_indicator" type="guint"/>
+      <field name="submenu_placement" type="guint"/>
+      <field name="submenu_direction" type="guint"/>
+      <field name="right_justify" type="guint"/>
+      <field name="timer_from_keypress" type="guint"/>
+      <field name="from_menubar" type="guint"/>
+      <field name="timer" type="guint"/>
+      <signal name="activate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </signal>
+      <signal name="activate_item" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_size_request" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="requisition" type="gint*"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_size_allocate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="allocation" type="gint"/>
+        </parameters>
+      </signal>
+      <method name="activate" symbol="gtk_menu_item_activate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="deselect" symbol="gtk_menu_item_deselect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_right_justified" symbol="gtk_menu_item_get_right_justified">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_submenu" symbol="gtk_menu_item_get_submenu">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_menu_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_menu_item_new"/>
+      <constructor name="new_with_label" symbol="gtk_menu_item_new_with_label">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_menu_item_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="remove_submenu" symbol="gtk_menu_item_remove_submenu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="select" symbol="gtk_menu_item_select">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_path" symbol="gtk_menu_item_set_accel_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="accel_path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_right_justified" symbol="gtk_menu_item_set_right_justified">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="right_justified" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_submenu" symbol="gtk_menu_item_set_submenu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="submenu" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="toggle_size_allocate" symbol="gtk_menu_item_toggle_size_allocate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="allocation" type="gint"/>
+        </parameters>
+      </method>
+      <method name="toggle_size_request" symbol="gtk_menu_item_toggle_size_request">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_item" type="GtkMenuItem*"/>
+          <parameter name="requisition" type="gint*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMenuShell" parent="GtkContainer" type-name="GtkMenuShell">
+      <field name="children" type="GList*"/>
+      <field name="active_menu_item" type="GtkWidget*"/>
+      <field name="parent_menu_shell" type="GtkWidget*"/>
+      <field name="button" type="guint"/>
+      <field name="activate_time" type="guint32"/>
+      <field name="active" type="guint"/>
+      <field name="have_grab" type="guint"/>
+      <field name="have_xgrab" type="guint"/>
+      <field name="ignore_leave" type="guint"/>
+      <field name="menu_flag" type="guint"/>
+      <field name="ignore_enter" type="guint"/>
+      <signal name="deactivate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </signal>
+      <signal name="selection_done" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </signal>
+      <signal name="move_current" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="direction" type="GtkMenuDirectionType"/>
+        </parameters>
+      </signal>
+      <signal name="activate_current" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="force_hide" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="cancel" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </signal>
+      <property name="take-focus" readable="1" type="gboolean" writable="1"/>
+      <vfunc name="select_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="menu_item" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_popup_delay">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </vfunc>
+      <method name="activate_item" symbol="gtk_menu_shell_activate_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="menu_item" type="GtkWidget*"/>
+          <parameter name="force_deactivate" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="append" symbol="gtk_menu_shell_append">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="cancel" symbol="gtk_menu_shell_cancel">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </method>
+      <method name="deactivate" symbol="gtk_menu_shell_deactivate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </method>
+      <method name="deselect" symbol="gtk_menu_shell_deselect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </method>
+      <method name="get_take_focus" symbol="gtk_menu_shell_get_take_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_menu_shell_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert" symbol="gtk_menu_shell_insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="prepend" symbol="gtk_menu_shell_prepend">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="select_first" symbol="gtk_menu_shell_select_first">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="search_sensitive" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="select_item" symbol="gtk_menu_shell_select_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="menu_item" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_take_focus" symbol="gtk_menu_shell_set_take_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu_shell" type="GtkMenuShell*"/>
+          <parameter name="take_focus" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMenuToolButton" parent="GtkToolButton" type-name="GtkMenuToolButton">
+      <field name="priv" type="GtkMenuToolButtonPrivate*"/>
+      <signal name="show_menu" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkMenuToolButton*"/>
+        </parameters>
+      </signal>
+      <property name="menu" readable="1" type="GtkMenu" writable="1"/>
+      <method name="get_menu" symbol="gtk_menu_tool_button_get_menu">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="button" type="GtkMenuToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_menu_tool_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_menu_tool_button_new">
+        <parameters>
+          <parameter name="icon_widget" type="GtkWidget*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_stock" symbol="gtk_menu_tool_button_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_arrow_tooltip" symbol="gtk_menu_tool_button_set_arrow_tooltip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkMenuToolButton*"/>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+          <parameter name="tip_text" type="const-gchar*"/>
+          <parameter name="tip_private" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_menu" symbol="gtk_menu_tool_button_set_menu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkMenuToolButton*"/>
+          <parameter name="menu" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMessageDialog" parent="GtkDialog" type-name="GtkMessageDialog">
+      <field name="image" type="GtkWidget*"/>
+      <field name="label" type="GtkWidget*"/>
+      <property construct="1" name="message-type" readable="1" type="GtkMessageType" writable="1"/>
+      <property construct-only="1" name="buttons" type="GtkButtonsType" writable="1"/>
+      <property name="text" readable="1" type="gchar*" writable="1"/>
+      <property name="use-markup" readable="1" type="gboolean" writable="1"/>
+      <property name="secondary-text" readable="1" type="gchar*" writable="1"/>
+      <property name="secondary-use-markup" readable="1" type="gboolean" writable="1"/>
+      <property name="image" readable="1" type="GtkWidget" writable="1"/>
+      <method name="format_secondary_markup" symbol="gtk_message_dialog_format_secondary_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="message_dialog" type="GtkMessageDialog*"/>
+          <parameter name="message_format" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="format_secondary_text" symbol="gtk_message_dialog_format_secondary_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="message_dialog" type="GtkMessageDialog*"/>
+          <parameter name="message_format" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_message_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_message_dialog_new">
+        <parameters>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="flags" type="GtkDialogFlags"/>
+          <parameter name="type" type="GtkMessageType"/>
+          <parameter name="buttons" type="GtkButtonsType"/>
+          <parameter name="message_format" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_markup" symbol="gtk_message_dialog_new_with_markup">
+        <parameters>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="flags" type="GtkDialogFlags"/>
+          <parameter name="type" type="GtkMessageType"/>
+          <parameter name="buttons" type="GtkButtonsType"/>
+          <parameter name="message_format" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_image" symbol="gtk_message_dialog_set_image">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkMessageDialog*"/>
+          <parameter name="image" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_markup" symbol="gtk_message_dialog_set_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="message_dialog" type="GtkMessageDialog*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkMisc" parent="GtkWidget" type-name="GtkMisc">
+      <field name="xalign" type="gfloat"/>
+      <field name="yalign" type="gfloat"/>
+      <field name="xpad" type="guint16"/>
+      <field name="ypad" type="guint16"/>
+      <property name="xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="yalign" readable="1" type="gfloat" writable="1"/>
+      <property name="xpad" readable="1" type="gint" writable="1"/>
+      <property name="ypad" readable="1" type="gint" writable="1"/>
+      <method name="get_alignment" symbol="gtk_misc_get_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="misc" type="GtkMisc*"/>
+          <parameter name="xalign" type="gfloat*"/>
+          <parameter name="yalign" type="gfloat*"/>
+        </parameters>
+      </method>
+      <method name="get_padding" symbol="gtk_misc_get_padding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="misc" type="GtkMisc*"/>
+          <parameter name="xpad" type="gint*"/>
+          <parameter name="ypad" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_misc_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_alignment" symbol="gtk_misc_set_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="misc" type="GtkMisc*"/>
+          <parameter name="xalign" type="gfloat"/>
+          <parameter name="yalign" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_padding" symbol="gtk_misc_set_padding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="misc" type="GtkMisc*"/>
+          <parameter name="xpad" type="gint"/>
+          <parameter name="ypad" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkNotebook" parent="GtkContainer" type-name="GtkNotebook">
+      <field name="cur_page" type="GtkNotebookPage*"/>
+      <field name="children" type="GList*"/>
+      <field name="first_tab" type="GList*"/>
+      <field name="focus_tab" type="GList*"/>
+      <field name="menu" type="GtkWidget*"/>
+      <field name="event_window" type="GdkWindow*"/>
+      <field name="timer" type="guint32"/>
+      <field name="tab_hborder" type="guint16"/>
+      <field name="tab_vborder" type="guint16"/>
+      <field name="show_tabs" type="guint"/>
+      <field name="homogeneous" type="guint"/>
+      <field name="show_border" type="guint"/>
+      <field name="tab_pos" type="guint"/>
+      <field name="scrollable" type="guint"/>
+      <field name="in_child" type="guint"/>
+      <field name="click_child" type="guint"/>
+      <field name="button" type="guint"/>
+      <field name="need_timer" type="guint"/>
+      <field name="child_has_focus" type="guint"/>
+      <field name="have_visible_child" type="guint"/>
+      <field name="focus_out" type="guint"/>
+      <field name="has_before_previous" type="guint"/>
+      <field name="has_before_next" type="guint"/>
+      <field name="has_after_previous" type="guint"/>
+      <field name="has_after_next" type="guint"/>
+      <property name="page" readable="1" type="gint" writable="1"/>
+      <property name="tab-pos" readable="1" type="GtkPositionType" writable="1"/>
+      <property name="tab-border" type="guint" writable="1"/>
+      <property name="tab-hborder" readable="1" type="guint" writable="1"/>
+      <property name="tab-vborder" readable="1" type="guint" writable="1"/>
+      <property name="show-tabs" readable="1" type="gboolean" writable="1"/>
+      <property name="show-border" readable="1" type="gboolean" writable="1"/>
+      <property name="scrollable" readable="1" type="gboolean" writable="1"/>
+      <property name="enable-popup" readable="1" type="gboolean" writable="1"/>
+      <property name="homogeneous" readable="1" type="gboolean" writable="1"/>
+      <property name="group-id" readable="1" type="gint" writable="1"/>
+      <signal name="switch_page" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="page" type="GtkNotebookPage*"/>
+          <parameter name="page_num" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="focus_tab" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="type" type="GtkNotebookTab"/>
+        </parameters>
+      </signal>
+      <signal name="select_page" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="move_focus" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="change_current_page" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="offset" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="move_focus_out" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+        </parameters>
+      </signal>
+      <signal name="reorder_tab" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+          <parameter name="move_to_last" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="page_reordered" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkNotebook*"/>
+          <parameter name="p0" type="GtkWidget"/>
+          <parameter name="p1" type="guint32"/>
+        </parameters>
+      </signal>
+      <signal name="page_removed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkNotebook*"/>
+          <parameter name="p0" type="GtkWidget"/>
+          <parameter name="p1" type="guint32"/>
+        </parameters>
+      </signal>
+      <signal name="page_added" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkNotebook*"/>
+          <parameter name="p0" type="GtkWidget"/>
+          <parameter name="p1" type="guint32"/>
+        </parameters>
+      </signal>
+      <vfunc name="insert_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+          <parameter name="menu_label" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="append_page" symbol="gtk_notebook_append_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="append_page_menu" symbol="gtk_notebook_append_page_menu">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+          <parameter name="menu_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_current_page" symbol="gtk_notebook_get_current_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_group_id" symbol="gtk_notebook_get_group_id">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_menu_label" symbol="gtk_notebook_get_menu_label">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_menu_label_text" symbol="gtk_notebook_get_menu_label_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_n_pages" symbol="gtk_notebook_get_n_pages">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_nth_page" symbol="gtk_notebook_get_nth_page">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="page_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_scrollable" symbol="gtk_notebook_get_scrollable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_show_border" symbol="gtk_notebook_get_show_border">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_show_tabs" symbol="gtk_notebook_get_show_tabs">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_tab_detachable" symbol="gtk_notebook_get_tab_detachable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_tab_label" symbol="gtk_notebook_get_tab_label">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_tab_label_text" symbol="gtk_notebook_get_tab_label_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_tab_pos" symbol="gtk_notebook_get_tab_pos">
+        <return-type type="GtkPositionType"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="get_tab_reorderable" symbol="gtk_notebook_get_tab_reorderable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_notebook_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert_page" symbol="gtk_notebook_insert_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_page_menu" symbol="gtk_notebook_insert_page_menu">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+          <parameter name="menu_label" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_notebook_new"/>
+      <method name="next_page" symbol="gtk_notebook_next_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="popup_disable" symbol="gtk_notebook_popup_disable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="popup_enable" symbol="gtk_notebook_popup_enable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="prepend_page" symbol="gtk_notebook_prepend_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="prepend_page_menu" symbol="gtk_notebook_prepend_page_menu">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+          <parameter name="menu_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="prev_page" symbol="gtk_notebook_prev_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+        </parameters>
+      </method>
+      <method name="query_tab_label_packing" symbol="gtk_notebook_query_tab_label_packing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="expand" type="gboolean*"/>
+          <parameter name="fill" type="gboolean*"/>
+          <parameter name="pack_type" type="GtkPackType*"/>
+        </parameters>
+      </method>
+      <method name="remove_page" symbol="gtk_notebook_remove_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="page_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="reorder_child" symbol="gtk_notebook_reorder_child">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_current_page" symbol="gtk_notebook_set_current_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="page_num" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_group_id" symbol="gtk_notebook_set_group_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="group_id" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_homogeneous_tabs" symbol="gtk_notebook_set_homogeneous_tabs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="homogeneous" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_menu_label" symbol="gtk_notebook_set_menu_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="menu_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_menu_label_text" symbol="gtk_notebook_set_menu_label_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="menu_text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_scrollable" symbol="gtk_notebook_set_scrollable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="scrollable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_border" symbol="gtk_notebook_set_show_border">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="show_border" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_show_tabs" symbol="gtk_notebook_set_show_tabs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="show_tabs" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_tab_border" symbol="gtk_notebook_set_tab_border">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="border_width" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_tab_detachable" symbol="gtk_notebook_set_tab_detachable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="detachable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_tab_hborder" symbol="gtk_notebook_set_tab_hborder">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="tab_hborder" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_tab_label" symbol="gtk_notebook_set_tab_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_tab_label_packing" symbol="gtk_notebook_set_tab_label_packing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="expand" type="gboolean"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="pack_type" type="GtkPackType"/>
+        </parameters>
+      </method>
+      <method name="set_tab_label_text" symbol="gtk_notebook_set_tab_label_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_tab_pos" symbol="gtk_notebook_set_tab_pos">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="pos" type="GtkPositionType"/>
+        </parameters>
+      </method>
+      <method name="set_tab_reorderable" symbol="gtk_notebook_set_tab_reorderable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="reorderable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_tab_vborder" symbol="gtk_notebook_set_tab_vborder">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="tab_vborder" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_window_creation_hook" symbol="gtk_notebook_set_window_creation_hook">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="func" type="GtkNotebookWindowCreationFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkObject" parent="GInitiallyUnowned" type-name="GtkObject">
+      <field name="flags" type="guint32"/>
+      <property name="user-data" readable="1" type="gpointer" writable="1"/>
+      <signal name="destroy" when="CLEANUP">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </signal>
+      <vfunc name="set_arg">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="arg" type="GtkArg*"/>
+          <parameter name="arg_id" type="guint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_arg">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="arg" type="GtkArg*"/>
+          <parameter name="arg_id" type="guint"/>
+        </parameters>
+      </vfunc>
+      <method deprecated="1" name="add_arg_type" symbol="gtk_object_add_arg_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="arg_name" type="const-gchar*"/>
+          <parameter name="arg_type" type="GtkType"/>
+          <parameter name="arg_flags" type="guint"/>
+          <parameter name="arg_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="gtk_object_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get" symbol="gtk_object_get">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_data" symbol="gtk_object_get_data">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_data_by_id" symbol="gtk_object_get_data_by_id">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="data_id" type="GQuark"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_object_get_type">
+        <return-type type="GtkType"/>
+      </method>
+      <method deprecated="1" name="get_user_data" symbol="gtk_object_get_user_data">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <constructor deprecated="1" name="new" symbol="gtk_object_new">
+        <parameters>
+          <parameter name="type" type="GtkType"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method deprecated="1" name="ref" symbol="gtk_object_ref">
+        <return-type type="GtkObject*"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove_data" symbol="gtk_object_remove_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove_data_by_id" symbol="gtk_object_remove_data_by_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="data_id" type="GQuark"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove_no_notify" symbol="gtk_object_remove_no_notify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove_no_notify_by_id" symbol="gtk_object_remove_no_notify_by_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="key_id" type="GQuark"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set" symbol="gtk_object_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_data" symbol="gtk_object_set_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_data_by_id" symbol="gtk_object_set_data_by_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="data_id" type="GQuark"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_data_by_id_full" symbol="gtk_object_set_data_by_id_full">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="data_id" type="GQuark"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_data_full" symbol="gtk_object_set_data_full">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_user_data" symbol="gtk_object_set_user_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="sink" symbol="gtk_object_sink">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gtk_object_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="weakref" symbol="gtk_object_weakref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="notify" type="GtkDestroyNotify"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="weakunref" symbol="gtk_object_weakunref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="notify" type="GtkDestroyNotify"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+    </object>
+    <object deprecated="1" get-type="" name="GtkOptionMenu" parent="GtkButton" type-name="GtkOptionMenu">
+      <field name="menu" type="GtkWidget*"/>
+      <field name="menu_item" type="GtkWidget*"/>
+      <field name="width" type="guint16"/>
+      <field name="height" type="guint16"/>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option_menu" type="GtkOptionMenu*"/>
+        </parameters>
+      </signal>
+      <property name="menu" readable="1" type="GtkMenu" writable="1"/>
+      <method deprecated="1" name="get_history" symbol="gtk_option_menu_get_history">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="option_menu" type="GtkOptionMenu*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_menu" symbol="gtk_option_menu_get_menu">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="option_menu" type="GtkOptionMenu*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_type" symbol="gtk_option_menu_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor deprecated="1" name="new" symbol="gtk_option_menu_new"/>
+      <method deprecated="1" name="remove_menu" symbol="gtk_option_menu_remove_menu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option_menu" type="GtkOptionMenu*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_history" symbol="gtk_option_menu_set_history">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option_menu" type="GtkOptionMenu*"/>
+          <parameter name="index_" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_menu" symbol="gtk_option_menu_set_menu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option_menu" type="GtkOptionMenu*"/>
+          <parameter name="menu" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPageSetup" parent="GObject" type-name="GtkPageSetup">
+      <method name="copy" symbol="gtk_page_setup_copy">
+        <return-type type="GtkPageSetup*"/>
+        <parameters>
+          <parameter name="other" type="GtkPageSetup*"/>
+        </parameters>
+      </method>
+      <method name="get_bottom_margin" symbol="gtk_page_setup_get_bottom_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_left_margin" symbol="gtk_page_setup_get_left_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_orientation" symbol="gtk_page_setup_get_orientation">
+        <return-type type="GtkPageOrientation"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+        </parameters>
+      </method>
+      <method name="get_page_height" symbol="gtk_page_setup_get_page_height">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_page_width" symbol="gtk_page_setup_get_page_width">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_paper_height" symbol="gtk_page_setup_get_paper_height">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_paper_size" symbol="gtk_page_setup_get_paper_size">
+        <return-type type="GtkPaperSize*"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+        </parameters>
+      </method>
+      <method name="get_paper_width" symbol="gtk_page_setup_get_paper_width">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_right_margin" symbol="gtk_page_setup_get_right_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_top_margin" symbol="gtk_page_setup_get_top_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_page_setup_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_page_setup_new"/>
+      <method name="set_bottom_margin" symbol="gtk_page_setup_set_bottom_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="margin" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_left_margin" symbol="gtk_page_setup_set_left_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="margin" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_orientation" symbol="gtk_page_setup_set_orientation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="orientation" type="GtkPageOrientation"/>
+        </parameters>
+      </method>
+      <method name="set_paper_size" symbol="gtk_page_setup_set_paper_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="set_paper_size_and_default_margins" symbol="gtk_page_setup_set_paper_size_and_default_margins">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="set_right_margin" symbol="gtk_page_setup_set_right_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="margin" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_top_margin" symbol="gtk_page_setup_set_top_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setup" type="GtkPageSetup*"/>
+          <parameter name="margin" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPageSetupUnixDialog" parent="GtkDialog" type-name="GtkPageSetupUnixDialog">
+      <field name="priv" type="GtkPageSetupUnixDialogPrivate*"/>
+      <method name="get_page_setup" symbol="gtk_page_setup_unix_dialog_get_page_setup">
+        <return-type type="GtkPageSetup*"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPageSetupUnixDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_print_settings" symbol="gtk_page_setup_unix_dialog_get_print_settings">
+        <return-type type="GtkPrintSettings*"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPageSetupUnixDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_page_setup_unix_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_page_setup_unix_dialog_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+        </parameters>
+      </constructor>
+      <method name="set_page_setup" symbol="gtk_page_setup_unix_dialog_set_page_setup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPageSetupUnixDialog*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+        </parameters>
+      </method>
+      <method name="set_print_settings" symbol="gtk_page_setup_unix_dialog_set_print_settings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPageSetupUnixDialog*"/>
+          <parameter name="print_settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPaned" parent="GtkContainer" type-name="GtkPaned">
+      <field name="child1" type="GtkWidget*"/>
+      <field name="child2" type="GtkWidget*"/>
+      <field name="handle" type="GdkWindow*"/>
+      <field name="xor_gc" type="GdkGC*"/>
+      <field name="cursor_type" type="GdkCursorType"/>
+      <field name="handle_pos" type="GdkRectangle"/>
+      <field name="child1_size" type="gint"/>
+      <field name="last_allocation" type="gint"/>
+      <field name="min_position" type="gint"/>
+      <field name="max_position" type="gint"/>
+      <field name="position_set" type="guint"/>
+      <field name="in_drag" type="guint"/>
+      <field name="child1_shrink" type="guint"/>
+      <field name="child1_resize" type="guint"/>
+      <field name="child2_shrink" type="guint"/>
+      <field name="child2_resize" type="guint"/>
+      <field name="orientation" type="guint"/>
+      <field name="in_recursion" type="guint"/>
+      <field name="handle_prelit" type="guint"/>
+      <field name="last_child1_focus" type="GtkWidget*"/>
+      <field name="last_child2_focus" type="GtkWidget*"/>
+      <field name="priv" type="GtkPanedPrivate*"/>
+      <field name="drag_pos" type="gint"/>
+      <field name="original_position" type="gint"/>
+      <property name="position" readable="1" type="gint" writable="1"/>
+      <property name="position-set" readable="1" type="gboolean" writable="1"/>
+      <property name="min-position" readable="1" type="gint"/>
+      <property name="max-position" readable="1" type="gint"/>
+      <signal name="cycle_child_focus" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="reverse" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_handle_focus" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+        </parameters>
+      </signal>
+      <signal name="move_handle" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="scroll" type="GtkScrollType"/>
+        </parameters>
+      </signal>
+      <signal name="cycle_handle_focus" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="reverse" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="accept_position" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+        </parameters>
+      </signal>
+      <signal name="cancel_position" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+        </parameters>
+      </signal>
+      <method name="add1" symbol="gtk_paned_add1">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="add2" symbol="gtk_paned_add2">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="compute_position" symbol="gtk_paned_compute_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="allocation" type="gint"/>
+          <parameter name="child1_req" type="gint"/>
+          <parameter name="child2_req" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_child1" symbol="gtk_paned_get_child1">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+        </parameters>
+      </method>
+      <method name="get_child2" symbol="gtk_paned_get_child2">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+        </parameters>
+      </method>
+      <method name="get_position" symbol="gtk_paned_get_position">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_paned_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="pack1" symbol="gtk_paned_pack1">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="resize" type="gboolean"/>
+          <parameter name="shrink" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="pack2" symbol="gtk_paned_pack2">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="resize" type="gboolean"/>
+          <parameter name="shrink" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_position" symbol="gtk_paned_set_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="paned" type="GtkPaned*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPlug" parent="GtkWindow" type-name="GtkPlug">
+      <field name="socket_window" type="GdkWindow*"/>
+      <field name="modality_window" type="GtkWidget*"/>
+      <field name="modality_group" type="GtkWindowGroup*"/>
+      <field name="grabbed_keys" type="GHashTable*"/>
+      <field name="same_app" type="guint"/>
+      <signal name="embedded" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="plug" type="GtkPlug*"/>
+        </parameters>
+      </signal>
+      <method name="construct" symbol="gtk_plug_construct">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="plug" type="GtkPlug*"/>
+          <parameter name="socket_id" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="construct_for_display" symbol="gtk_plug_construct_for_display">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="plug" type="GtkPlug*"/>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="socket_id" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="get_id" symbol="gtk_plug_get_id">
+        <return-type type="GdkNativeWindow"/>
+        <parameters>
+          <parameter name="plug" type="GtkPlug*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_plug_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_plug_new">
+        <parameters>
+          <parameter name="socket_id" type="GdkNativeWindow"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_for_display" symbol="gtk_plug_new_for_display">
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="socket_id" type="GdkNativeWindow"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkPrinter" parent="GObject" type-name="GtkPrinter">
+      <field name="priv" type="GtkPrinterPrivate*"/>
+      <property construct-only="1" name="name" readable="1" type="gchar*" writable="1"/>
+      <property construct-only="1" name="backend" readable="1" type="GtkPrintBackend" writable="1"/>
+      <property construct-only="1" name="is-virtual" readable="1" type="gboolean" writable="1"/>
+      <property construct-only="1" name="accepts-pdf" readable="1" type="gboolean" writable="1"/>
+      <property construct-only="1" name="accepts-ps" readable="1" type="gboolean" writable="1"/>
+      <property name="state-message" readable="1" type="gchar*"/>
+      <property name="location" readable="1" type="gchar*"/>
+      <property name="icon-name" readable="1" type="gchar*"/>
+      <property name="job-count" readable="1" type="gint"/>
+      <signal name="details_acquired" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="success" type="gboolean"/>
+        </parameters>
+      </signal>
+      <method name="accepts_pdf" symbol="gtk_printer_accepts_pdf">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="accepts_ps" symbol="gtk_printer_accepts_ps">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="compare" symbol="gtk_printer_compare">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="a" type="GtkPrinter*"/>
+          <parameter name="b" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_backend" symbol="gtk_printer_get_backend">
+        <return-type type="GtkPrintBackend*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_description" symbol="gtk_printer_get_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_name" symbol="gtk_printer_get_icon_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_job_count" symbol="gtk_printer_get_job_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_location" symbol="gtk_printer_get_location">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_printer_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_state_message" symbol="gtk_printer_get_state_message">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_printer_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_active" symbol="gtk_printer_is_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="is_default" symbol="gtk_printer_is_default">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="is_new" symbol="gtk_printer_is_new">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="is_virtual" symbol="gtk_printer_is_virtual">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_printer_new">
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+          <parameter name="virtual_" type="gboolean"/>
+        </parameters>
+      </constructor>
+      <method name="set_description" symbol="gtk_printer_set_description">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="description" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_has_details" symbol="gtk_printer_set_has_details">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="val" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_icon_name" symbol="gtk_printer_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="icon" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_is_active" symbol="gtk_printer_set_is_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="active" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_is_default" symbol="gtk_printer_set_is_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="val" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_is_new" symbol="gtk_printer_set_is_new">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="val" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_job_count" symbol="gtk_printer_set_job_count">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_location" symbol="gtk_printer_set_location">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="location" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_state_message" symbol="gtk_printer_set_state_message">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="message" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrinterOption" parent="GObject" type-name="GtkPrinterOption">
+      <field name="name" type="char*"/>
+      <field name="display_text" type="char*"/>
+      <field name="type" type="GtkPrinterOptionType"/>
+      <field name="value" type="char*"/>
+      <field name="num_choices" type="int"/>
+      <field name="choices" type="char**"/>
+      <field name="choices_display" type="char**"/>
+      <field name="has_conflict" type="gboolean"/>
+      <field name="group" type="char*"/>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+        </parameters>
+      </signal>
+      <method name="allocate_choices" symbol="gtk_printer_option_allocate_choices">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+          <parameter name="num" type="int"/>
+        </parameters>
+      </method>
+      <method name="choices_from_array" symbol="gtk_printer_option_choices_from_array">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+          <parameter name="num_choices" type="int"/>
+          <parameter name="choices" type="char*[]"/>
+          <parameter name="choices_display" type="char*[]"/>
+        </parameters>
+      </method>
+      <method name="clear_has_conflict" symbol="gtk_printer_option_clear_has_conflict">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_printer_option_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="has_choice" symbol="gtk_printer_option_has_choice">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+          <parameter name="choice" type="const-char*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_printer_option_new">
+        <parameters>
+          <parameter name="name" type="const-char*"/>
+          <parameter name="display_text" type="const-char*"/>
+          <parameter name="type" type="GtkPrinterOptionType"/>
+        </parameters>
+      </constructor>
+      <method name="set" symbol="gtk_printer_option_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+          <parameter name="value" type="const-char*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrinterOptionSet" parent="GObject" type-name="GtkPrinterOptionSet">
+      <field name="array" type="GPtrArray*"/>
+      <field name="hash" type="GHashTable*"/>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOptionSet*"/>
+        </parameters>
+      </signal>
+      <method name="add" symbol="gtk_printer_option_set_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+          <parameter name="option" type="GtkPrinterOption*"/>
+        </parameters>
+      </method>
+      <method name="boolean" symbol="gtk_printer_option_set_boolean">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+          <parameter name="value" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="clear_conflicts" symbol="gtk_printer_option_set_clear_conflicts">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+        </parameters>
+      </method>
+      <method name="foreach" symbol="gtk_printer_option_set_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+          <parameter name="func" type="GtkPrinterOptionSetFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="foreach_in_group" symbol="gtk_printer_option_set_foreach_in_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+          <parameter name="group" type="const-char*"/>
+          <parameter name="func" type="GtkPrinterOptionSetFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="get_groups" symbol="gtk_printer_option_set_get_groups">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_printer_option_set_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="has_conflict" symbol="gtk_printer_option_set_has_conflict">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="option" type="GtkPrinterOption*"/>
+          <parameter name="has_conflict" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="lookup" symbol="gtk_printer_option_set_lookup">
+        <return-type type="GtkPrinterOption*"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+          <parameter name="name" type="const-char*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_printer_option_set_new"/>
+      <method name="remove" symbol="gtk_printer_option_set_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="set" type="GtkPrinterOptionSet*"/>
+          <parameter name="option" type="GtkPrinterOption*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrinterOptionWidget" parent="GtkHBox" type-name="GtkPrinterOptionWidget">
+      <field name="priv" type="GtkPrinterOptionWidgetPrivate*"/>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkPrinterOptionWidget*"/>
+        </parameters>
+      </signal>
+      <property construct="1" name="source" readable="1" type="GtkPrinterOption" writable="1"/>
+      <method name="get_external_label" symbol="gtk_printer_option_widget_get_external_label">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="setting" type="GtkPrinterOptionWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_printer_option_widget_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_value" symbol="gtk_printer_option_widget_get_value">
+        <return-type type="const-char*"/>
+        <parameters>
+          <parameter name="setting" type="GtkPrinterOptionWidget*"/>
+        </parameters>
+      </method>
+      <method name="has_external_label" symbol="gtk_printer_option_widget_has_external_label">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="setting" type="GtkPrinterOptionWidget*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_printer_option_widget_new">
+        <parameters>
+          <parameter name="source" type="GtkPrinterOption*"/>
+        </parameters>
+      </constructor>
+      <method name="set_source" symbol="gtk_printer_option_widget_set_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setting" type="GtkPrinterOptionWidget*"/>
+          <parameter name="source" type="GtkPrinterOption*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrintBackend" parent="GObject" type-name="GtkPrintBackend">
+      <field name="priv" type="GtkPrintBackendPrivate*"/>
+      <signal name="printer_list_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </signal>
+      <signal name="printer_list_done" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </signal>
+      <signal name="printer_added" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </signal>
+      <signal name="printer_removed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </signal>
+      <signal name="printer_status_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </signal>
+      <vfunc name="request_printer_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="print_stream">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+          <parameter name="job" type="GtkPrintJob*"/>
+          <parameter name="data_io" type="GIOChannel*"/>
+          <parameter name="callback" type="GtkPrintJobCompleteFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="dnotify" type="GDestroyNotify"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_request_details">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_create_cairo_surface">
+        <return-type type="cairo_surface_t*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="height" type="gdouble"/>
+          <parameter name="width" type="gdouble"/>
+          <parameter name="cache_io" type="GIOChannel*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_get_options">
+        <return-type type="GtkPrinterOptionSet*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+          <parameter name="capabilities" type="GtkPrintCapabilities"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_mark_conflicts">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="options" type="GtkPrinterOptionSet*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_get_settings_from_options">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="options" type="GtkPrinterOptionSet*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_prepare_for_print">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="print_job" type="GtkPrintJob*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_list_papers">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_get_hard_margins">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="top" type="double*"/>
+          <parameter name="bottom" type="double*"/>
+          <parameter name="left" type="double*"/>
+          <parameter name="right" type="double*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="printer_get_capabilities">
+        <return-type type="GtkPrintCapabilities"/>
+        <parameters>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_printer" symbol="gtk_print_backend_add_printer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="gtk_print_backend_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </method>
+      <method name="error_quark" symbol="gtk_print_backend_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="find_printer" symbol="gtk_print_backend_find_printer">
+        <return-type type="GtkPrinter*"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+          <parameter name="printer_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_printer_list" symbol="gtk_print_backend_get_printer_list">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_backend_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="load_modules" symbol="gtk_print_backend_load_modules">
+        <return-type type="GList*"/>
+      </method>
+      <method name="print_stream" symbol="gtk_print_backend_print_stream">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+          <parameter name="job" type="GtkPrintJob*"/>
+          <parameter name="data_io" type="GIOChannel*"/>
+          <parameter name="callback" type="GtkPrintJobCompleteFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="dnotify" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="printer_list_is_done" symbol="gtk_print_backend_printer_list_is_done">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </method>
+      <method name="remove_printer" symbol="gtk_print_backend_remove_printer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="print_backend" type="GtkPrintBackend*"/>
+          <parameter name="printer" type="GtkPrinter*"/>
+        </parameters>
+      </method>
+      <method name="set_list_done" symbol="gtk_print_backend_set_list_done">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="backend" type="GtkPrintBackend*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrintContext" parent="GObject" type-name="GtkPrintContext">
+      <method name="create_pango_context" symbol="gtk_print_context_create_pango_context">
+        <return-type type="PangoContext*"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="create_pango_layout" symbol="gtk_print_context_create_pango_layout">
+        <return-type type="PangoLayout*"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_cairo_context" symbol="gtk_print_context_get_cairo_context">
+        <return-type type="cairo_t*"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_dpi_x" symbol="gtk_print_context_get_dpi_x">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_dpi_y" symbol="gtk_print_context_get_dpi_y">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_height" symbol="gtk_print_context_get_height">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_page_setup" symbol="gtk_print_context_get_page_setup">
+        <return-type type="GtkPageSetup*"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_pango_fontmap" symbol="gtk_print_context_get_pango_fontmap">
+        <return-type type="PangoFontMap*"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_context_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="gtk_print_context_get_width">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </method>
+      <method name="set_cairo_context" symbol="gtk_print_context_set_cairo_context">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GtkPrintContext*"/>
+          <parameter name="cr" type="cairo_t*"/>
+          <parameter name="dpi_x" type="double"/>
+          <parameter name="dpi_y" type="double"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrintJob" parent="GObject" type-name="GtkPrintJob">
+      <field name="priv" type="GtkPrintJobPrivate*"/>
+      <field name="print_pages" type="GtkPrintPages"/>
+      <field name="page_ranges" type="GtkPageRange*"/>
+      <field name="num_page_ranges" type="gint"/>
+      <field name="page_set" type="GtkPageSet"/>
+      <field name="num_copies" type="gint"/>
+      <field name="scale" type="gdouble"/>
+      <field name="rotate_to_orientation" type="guint"/>
+      <field name="collate" type="guint"/>
+      <field name="reverse" type="guint"/>
+      <property construct-only="1" name="title" readable="1" type="gchar*" writable="1"/>
+      <property construct-only="1" name="printer" readable="1" type="GtkPrinter" writable="1"/>
+      <property construct-only="1" name="settings" readable="1" type="GtkPrintSettings" writable="1"/>
+      <property construct-only="1" name="page-setup" readable="1" type="GtkPageSetup" writable="1"/>
+      <property name="track-print-status" readable="1" type="gboolean" writable="1"/>
+      <signal name="status_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+        </parameters>
+      </signal>
+      <method name="get_printer" symbol="gtk_print_job_get_printer">
+        <return-type type="GtkPrinter*"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+        </parameters>
+      </method>
+      <method name="get_settings" symbol="gtk_print_job_get_settings">
+        <return-type type="GtkPrintSettings*"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+        </parameters>
+      </method>
+      <method name="get_status" symbol="gtk_print_job_get_status">
+        <return-type type="GtkPrintStatus"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+        </parameters>
+      </method>
+      <method name="get_surface" symbol="gtk_print_job_get_surface">
+        <return-type type="cairo_surface_t*"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_print_job_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+        </parameters>
+      </method>
+      <method name="get_track_print_status" symbol="gtk_print_job_get_track_print_status">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_job_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_print_job_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="printer" type="GtkPrinter*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+        </parameters>
+      </constructor>
+      <method name="send" symbol="gtk_print_job_send">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+          <parameter name="callback" type="GtkPrintJobCompleteFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="dnotify" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_source_file" symbol="gtk_print_job_set_source_file">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+          <parameter name="filename" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_track_print_status" symbol="gtk_print_job_set_track_print_status">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="job" type="GtkPrintJob*"/>
+          <parameter name="track_status" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrintOperation" parent="GObject" type-name="GtkPrintOperation">
+      <field name="priv" type="GtkPrintOperationPrivate*"/>
+      <signal name="done" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="result" type="GtkPrintOperationResult"/>
+        </parameters>
+      </signal>
+      <signal name="begin_print" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </signal>
+      <signal name="paginate" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </signal>
+      <signal name="request_page_setup" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+          <parameter name="page_nr" type="gint"/>
+          <parameter name="setup" type="GtkPageSetup*"/>
+        </parameters>
+      </signal>
+      <signal name="draw_page" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+          <parameter name="page_nr" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="end_print" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+        </parameters>
+      </signal>
+      <signal name="status_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+        </parameters>
+      </signal>
+      <signal name="create_custom_widget" when="LAST">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+        </parameters>
+      </signal>
+      <signal name="custom_widget_apply" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="preview" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="operation" type="GtkPrintOperation*"/>
+          <parameter name="preview" type="GtkPrintOperationPreview*"/>
+          <parameter name="context" type="GtkPrintContext*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+        </parameters>
+      </signal>
+      <property name="default-page-setup" readable="1" type="GtkPageSetup" writable="1"/>
+      <property name="print-settings" readable="1" type="GtkPrintSettings" writable="1"/>
+      <property name="job-name" readable="1" type="gchar*" writable="1"/>
+      <property name="n-pages" readable="1" type="gint" writable="1"/>
+      <property name="current-page" readable="1" type="gint" writable="1"/>
+      <property name="use-full-page" readable="1" type="gboolean" writable="1"/>
+      <property name="track-print-status" readable="1" type="gboolean" writable="1"/>
+      <property name="unit" readable="1" type="GtkUnit" writable="1"/>
+      <property name="show-progress" readable="1" type="gboolean" writable="1"/>
+      <property name="allow-async" readable="1" type="gboolean" writable="1"/>
+      <property name="export-filename" readable="1" type="gchar*" writable="1"/>
+      <property name="status" readable="1" type="GtkPrintStatus"/>
+      <property name="status-string" readable="1" type="gchar*"/>
+      <property name="custom-tab-label" readable="1" type="gchar*" writable="1"/>
+      <implements>
+        <interface name="GtkPrintOperationPreview"/>
+      </implements>
+      <method name="cancel" symbol="gtk_print_operation_cancel">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+        </parameters>
+      </method>
+      <method name="get_default_page_setup" symbol="gtk_print_operation_get_default_page_setup">
+        <return-type type="GtkPageSetup*"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+        </parameters>
+      </method>
+      <method name="get_error" symbol="gtk_print_operation_get_error">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="get_print_settings" symbol="gtk_print_operation_get_print_settings">
+        <return-type type="GtkPrintSettings*"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+        </parameters>
+      </method>
+      <method name="get_status" symbol="gtk_print_operation_get_status">
+        <return-type type="GtkPrintStatus"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+        </parameters>
+      </method>
+      <method name="get_status_string" symbol="gtk_print_operation_get_status_string">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_operation_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_finished" symbol="gtk_print_operation_is_finished">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_print_operation_new"/>
+      <method name="run" symbol="gtk_print_operation_run">
+        <return-type type="GtkPrintOperationResult"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="action" type="GtkPrintOperationAction"/>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_allow_async" symbol="gtk_print_operation_set_allow_async">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="allow_async" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_current_page" symbol="gtk_print_operation_set_current_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="current_page" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_custom_tab_label" symbol="gtk_print_operation_set_custom_tab_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_default_page_setup" symbol="gtk_print_operation_set_default_page_setup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="default_page_setup" type="GtkPageSetup*"/>
+        </parameters>
+      </method>
+      <method name="set_export_filename" symbol="gtk_print_operation_set_export_filename">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_job_name" symbol="gtk_print_operation_set_job_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="job_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_n_pages" symbol="gtk_print_operation_set_n_pages">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="n_pages" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_print_settings" symbol="gtk_print_operation_set_print_settings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="print_settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="set_show_progress" symbol="gtk_print_operation_set_show_progress">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="show_progress" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_track_print_status" symbol="gtk_print_operation_set_track_print_status">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="track_status" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_unit" symbol="gtk_print_operation_set_unit">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_use_full_page" symbol="gtk_print_operation_set_use_full_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="op" type="GtkPrintOperation*"/>
+          <parameter name="full_page" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrintSettings" parent="GObject" type-name="GtkPrintSettings">
+      <method name="copy" symbol="gtk_print_settings_copy">
+        <return-type type="GtkPrintSettings*"/>
+        <parameters>
+          <parameter name="other" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="foreach" symbol="gtk_print_settings_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="func" type="GtkPrintSettingsFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="gtk_print_settings_get">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_bool" symbol="gtk_print_settings_get_bool">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_collate" symbol="gtk_print_settings_get_collate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_default_source" symbol="gtk_print_settings_get_default_source">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_dither" symbol="gtk_print_settings_get_dither">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_double" symbol="gtk_print_settings_get_double">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_double_with_default" symbol="gtk_print_settings_get_double_with_default">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="def" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="get_duplex" symbol="gtk_print_settings_get_duplex">
+        <return-type type="GtkPrintDuplex"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_finishings" symbol="gtk_print_settings_get_finishings">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_int" symbol="gtk_print_settings_get_int">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_int_with_default" symbol="gtk_print_settings_get_int_with_default">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="def" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_length" symbol="gtk_print_settings_get_length">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_media_type" symbol="gtk_print_settings_get_media_type">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_n_copies" symbol="gtk_print_settings_get_n_copies">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_number_up" symbol="gtk_print_settings_get_number_up">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_orientation" symbol="gtk_print_settings_get_orientation">
+        <return-type type="GtkPageOrientation"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_output_bin" symbol="gtk_print_settings_get_output_bin">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_page_ranges" symbol="gtk_print_settings_get_page_ranges">
+        <return-type type="GtkPageRange*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="num_ranges" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_page_set" symbol="gtk_print_settings_get_page_set">
+        <return-type type="GtkPageSet"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_paper_height" symbol="gtk_print_settings_get_paper_height">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_paper_size" symbol="gtk_print_settings_get_paper_size">
+        <return-type type="GtkPaperSize*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_paper_width" symbol="gtk_print_settings_get_paper_width">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_print_pages" symbol="gtk_print_settings_get_print_pages">
+        <return-type type="GtkPrintPages"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_printer" symbol="gtk_print_settings_get_printer">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_quality" symbol="gtk_print_settings_get_quality">
+        <return-type type="GtkPrintQuality"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_resolution" symbol="gtk_print_settings_get_resolution">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_reverse" symbol="gtk_print_settings_get_reverse">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_scale" symbol="gtk_print_settings_get_scale">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_settings_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_color" symbol="gtk_print_settings_get_use_color">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="has_key" symbol="gtk_print_settings_has_key">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_print_settings_new"/>
+      <method name="set" symbol="gtk_print_settings_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="value" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_bool" symbol="gtk_print_settings_set_bool">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="value" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_collate" symbol="gtk_print_settings_set_collate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="collate" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_default_source" symbol="gtk_print_settings_set_default_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="default_source" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_dither" symbol="gtk_print_settings_set_dither">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="dither" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_double" symbol="gtk_print_settings_set_double">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_duplex" symbol="gtk_print_settings_set_duplex">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="duplex" type="GtkPrintDuplex"/>
+        </parameters>
+      </method>
+      <method name="set_finishings" symbol="gtk_print_settings_set_finishings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="finishings" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_int" symbol="gtk_print_settings_set_int">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="value" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_length" symbol="gtk_print_settings_set_length">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+          <parameter name="value" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_media_type" symbol="gtk_print_settings_set_media_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="media_type" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_n_copies" symbol="gtk_print_settings_set_n_copies">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="num_copies" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_number_up" symbol="gtk_print_settings_set_number_up">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="number_up" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_orientation" symbol="gtk_print_settings_set_orientation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="orientation" type="GtkPageOrientation"/>
+        </parameters>
+      </method>
+      <method name="set_output_bin" symbol="gtk_print_settings_set_output_bin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="output_bin" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_page_ranges" symbol="gtk_print_settings_set_page_ranges">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="page_ranges" type="GtkPageRange*"/>
+          <parameter name="num_ranges" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_page_set" symbol="gtk_print_settings_set_page_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="page_set" type="GtkPageSet"/>
+        </parameters>
+      </method>
+      <method name="set_paper_height" symbol="gtk_print_settings_set_paper_height">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="height" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_paper_size" symbol="gtk_print_settings_set_paper_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="paper_size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="set_paper_width" symbol="gtk_print_settings_set_paper_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="width" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="set_print_pages" symbol="gtk_print_settings_set_print_pages">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="pages" type="GtkPrintPages"/>
+        </parameters>
+      </method>
+      <method name="set_printer" symbol="gtk_print_settings_set_printer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="printer" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_quality" symbol="gtk_print_settings_set_quality">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="quality" type="GtkPrintQuality"/>
+        </parameters>
+      </method>
+      <method name="set_resolution" symbol="gtk_print_settings_set_resolution">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="resolution" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_reverse" symbol="gtk_print_settings_set_reverse">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="reverse" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_scale" symbol="gtk_print_settings_set_scale">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="scale" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_use_color" symbol="gtk_print_settings_set_use_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="use_color" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="unset" symbol="gtk_print_settings_unset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="key" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkPrintUnixDialog" parent="GtkDialog" type-name="GtkPrintUnixDialog">
+      <field name="priv" type="GtkPrintUnixDialogPrivate*"/>
+      <property name="page-setup" readable="1" type="GtkPageSetup" writable="1"/>
+      <property name="current-page" readable="1" type="gint" writable="1"/>
+      <property name="print-settings" readable="1" type="GtkPrintSettings" writable="1"/>
+      <property name="selected-printer" readable="1" type="GtkPrinter"/>
+      <method name="add_custom_tab" symbol="gtk_print_unix_dialog_add_custom_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="tab_label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_current_page" symbol="gtk_print_unix_dialog_get_current_page">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_page_setup" symbol="gtk_print_unix_dialog_get_page_setup">
+        <return-type type="GtkPageSetup*"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_selected_printer" symbol="gtk_print_unix_dialog_get_selected_printer">
+        <return-type type="GtkPrinter*"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_settings" symbol="gtk_print_unix_dialog_get_settings">
+        <return-type type="GtkPrintSettings*"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_print_unix_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_print_unix_dialog_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+        </parameters>
+      </constructor>
+      <method name="set_current_page" symbol="gtk_print_unix_dialog_set_current_page">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+          <parameter name="current_page" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_manual_capabilities" symbol="gtk_print_unix_dialog_set_manual_capabilities">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+          <parameter name="capabilities" type="GtkPrintCapabilities"/>
+        </parameters>
+      </method>
+      <method name="set_page_setup" symbol="gtk_print_unix_dialog_set_page_setup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+        </parameters>
+      </method>
+      <method name="set_settings" symbol="gtk_print_unix_dialog_set_settings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dialog" type="GtkPrintUnixDialog*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkProgress" parent="GtkWidget" type-name="GtkProgress">
+      <field name="adjustment" type="GtkAdjustment*"/>
+      <field name="offscreen_pixmap" type="GdkPixmap*"/>
+      <field name="format" type="gchar*"/>
+      <field name="x_align" type="gfloat"/>
+      <field name="y_align" type="gfloat"/>
+      <field name="show_text" type="guint"/>
+      <field name="activity_mode" type="guint"/>
+      <field name="use_text_format" type="guint"/>
+      <property name="activity-mode" readable="1" type="gboolean" writable="1"/>
+      <property name="show-text" readable="1" type="gboolean" writable="1"/>
+      <property name="text-xalign" readable="1" type="gfloat" writable="1"/>
+      <property name="text-yalign" readable="1" type="gfloat" writable="1"/>
+      <vfunc name="paint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="update">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="act_mode_enter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+        </parameters>
+      </vfunc>
+      <method deprecated="1" name="configure" symbol="gtk_progress_configure">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="value" type="gdouble"/>
+          <parameter name="hmin" type="gdouble"/>
+          <parameter name="max" type="gdouble"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_current_percentage" symbol="gtk_progress_get_current_percentage">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_current_text" symbol="gtk_progress_get_current_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_percentage_from_value" symbol="gtk_progress_get_percentage_from_value">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_text_from_value" symbol="gtk_progress_get_text_from_value">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_type" symbol="gtk_progress_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method deprecated="1" name="get_value" symbol="gtk_progress_get_value">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_activity_mode" symbol="gtk_progress_set_activity_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="activity_mode" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_adjustment" symbol="gtk_progress_set_adjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_format_string" symbol="gtk_progress_set_format_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="format" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_percentage" symbol="gtk_progress_set_percentage">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="percentage" type="gdouble"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_show_text" symbol="gtk_progress_set_show_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="show_text" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_text_alignment" symbol="gtk_progress_set_text_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="x_align" type="gfloat"/>
+          <parameter name="y_align" type="gfloat"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_value" symbol="gtk_progress_set_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="progress" type="GtkProgress*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkProgressBar" parent="GtkProgress" type-name="GtkProgressBar">
+      <field name="bar_style" type="GtkProgressBarStyle"/>
+      <field name="orientation" type="GtkProgressBarOrientation"/>
+      <field name="blocks" type="guint"/>
+      <field name="in_block" type="gint"/>
+      <field name="activity_pos" type="gint"/>
+      <field name="activity_step" type="guint"/>
+      <field name="activity_blocks" type="guint"/>
+      <field name="pulse_fraction" type="gdouble"/>
+      <field name="activity_dir" type="guint"/>
+      <field name="ellipsize" type="guint"/>
+      <field name="dirty" type="guint"/>
+      <property name="adjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="orientation" readable="1" type="GtkProgressBarOrientation" writable="1"/>
+      <property name="bar-style" readable="1" type="GtkProgressBarStyle" writable="1"/>
+      <property name="activity-step" readable="1" type="guint" writable="1"/>
+      <property name="activity-blocks" readable="1" type="guint" writable="1"/>
+      <property name="discrete-blocks" readable="1" type="guint" writable="1"/>
+      <property name="fraction" readable="1" type="gdouble" writable="1"/>
+      <property name="pulse-step" readable="1" type="gdouble" writable="1"/>
+      <property name="text" readable="1" type="gchar*" writable="1"/>
+      <property name="ellipsize" readable="1" type="PangoEllipsizeMode" writable="1"/>
+      <method name="get_ellipsize" symbol="gtk_progress_bar_get_ellipsize">
+        <return-type type="PangoEllipsizeMode"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+        </parameters>
+      </method>
+      <method name="get_fraction" symbol="gtk_progress_bar_get_fraction">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+        </parameters>
+      </method>
+      <method name="get_orientation" symbol="gtk_progress_bar_get_orientation">
+        <return-type type="GtkProgressBarOrientation"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+        </parameters>
+      </method>
+      <method name="get_pulse_step" symbol="gtk_progress_bar_get_pulse_step">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="gtk_progress_bar_get_text">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_progress_bar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_progress_bar_new"/>
+      <constructor deprecated="1" name="new_with_adjustment" symbol="gtk_progress_bar_new_with_adjustment">
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+      <method name="pulse" symbol="gtk_progress_bar_pulse">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_activity_blocks" symbol="gtk_progress_bar_set_activity_blocks">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="blocks" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_activity_step" symbol="gtk_progress_bar_set_activity_step">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="step" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_bar_style" symbol="gtk_progress_bar_set_bar_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="style" type="GtkProgressBarStyle"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_discrete_blocks" symbol="gtk_progress_bar_set_discrete_blocks">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="blocks" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_ellipsize" symbol="gtk_progress_bar_set_ellipsize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="mode" type="PangoEllipsizeMode"/>
+        </parameters>
+      </method>
+      <method name="set_fraction" symbol="gtk_progress_bar_set_fraction">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="fraction" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_orientation" symbol="gtk_progress_bar_set_orientation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="orientation" type="GtkProgressBarOrientation"/>
+        </parameters>
+      </method>
+      <method name="set_pulse_step" symbol="gtk_progress_bar_set_pulse_step">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="fraction" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="gtk_progress_bar_set_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="update" symbol="gtk_progress_bar_update">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pbar" type="GtkProgressBar*"/>
+          <parameter name="percentage" type="gdouble"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRadioAction" parent="GtkToggleAction" type-name="GtkRadioAction">
+      <field name="private_data" type="GtkRadioActionPrivate*"/>
+      <property name="value" readable="1" type="gint" writable="1"/>
+      <property name="group" type="GtkRadioAction" writable="1"/>
+      <property name="current-value" readable="1" type="gint" writable="1"/>
+      <signal name="changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkRadioAction*"/>
+          <parameter name="current" type="GtkRadioAction*"/>
+        </parameters>
+      </signal>
+      <method name="get_current_value" symbol="gtk_radio_action_get_current_value">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="action" type="GtkRadioAction*"/>
+        </parameters>
+      </method>
+      <method name="get_group" symbol="gtk_radio_action_get_group">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="action" type="GtkRadioAction*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_radio_action_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_radio_action_new">
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="label" type="const-gchar*"/>
+          <parameter name="tooltip" type="const-gchar*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="value" type="gint"/>
+        </parameters>
+      </constructor>
+      <method name="set_current_value" symbol="gtk_radio_action_set_current_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkRadioAction*"/>
+          <parameter name="current_value" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_group" symbol="gtk_radio_action_set_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkRadioAction*"/>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRadioButton" parent="GtkCheckButton" type-name="GtkRadioButton">
+      <field name="group" type="GSList*"/>
+      <property name="group" type="GtkRadioButton" writable="1"/>
+      <signal name="group_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="radio_button" type="GtkRadioButton*"/>
+        </parameters>
+      </signal>
+      <method name="get_group" symbol="gtk_radio_button_get_group">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="radio_button" type="GtkRadioButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_radio_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_radio_button_new">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_widget" symbol="gtk_radio_button_new_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioButton*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label" symbol="gtk_radio_button_new_with_label">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label_from_widget" symbol="gtk_radio_button_new_with_label_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioButton*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_radio_button_new_with_mnemonic">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic_from_widget" symbol="gtk_radio_button_new_with_mnemonic_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioButton*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_group" symbol="gtk_radio_button_set_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="radio_button" type="GtkRadioButton*"/>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRadioMenuItem" parent="GtkCheckMenuItem" type-name="GtkRadioMenuItem">
+      <field name="group" type="GSList*"/>
+      <property name="group" type="GtkRadioMenuItem" writable="1"/>
+      <signal name="group_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="radio_menu_item" type="GtkRadioMenuItem*"/>
+        </parameters>
+      </signal>
+      <method name="get_group" symbol="gtk_radio_menu_item_get_group">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="radio_menu_item" type="GtkRadioMenuItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_radio_menu_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_radio_menu_item_new">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_widget" symbol="gtk_radio_menu_item_new_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioMenuItem*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label" symbol="gtk_radio_menu_item_new_with_label">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_label_from_widget" symbol="gtk_radio_menu_item_new_with_label_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioMenuItem*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_radio_menu_item_new_with_mnemonic">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic_from_widget" symbol="gtk_radio_menu_item_new_with_mnemonic_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioMenuItem*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_group" symbol="gtk_radio_menu_item_set_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="radio_menu_item" type="GtkRadioMenuItem*"/>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRadioToolButton" parent="GtkToggleToolButton" type-name="GtkRadioToolButton">
+      <property name="group" type="GtkRadioToolButton" writable="1"/>
+      <method name="get_group" symbol="gtk_radio_tool_button_get_group">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="button" type="GtkRadioToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_radio_tool_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_radio_tool_button_new">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_stock" symbol="gtk_radio_tool_button_new_from_stock">
+        <parameters>
+          <parameter name="group" type="GSList*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_widget" symbol="gtk_radio_tool_button_new_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioToolButton*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_stock_from_widget" symbol="gtk_radio_tool_button_new_with_stock_from_widget">
+        <parameters>
+          <parameter name="group" type="GtkRadioToolButton*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_group" symbol="gtk_radio_tool_button_set_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkRadioToolButton*"/>
+          <parameter name="group" type="GSList*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRange" parent="GtkWidget" type-name="GtkRange">
+      <field name="adjustment" type="GtkAdjustment*"/>
+      <field name="update_policy" type="GtkUpdateType"/>
+      <field name="inverted" type="guint"/>
+      <field name="flippable" type="guint"/>
+      <field name="has_stepper_a" type="guint"/>
+      <field name="has_stepper_b" type="guint"/>
+      <field name="has_stepper_c" type="guint"/>
+      <field name="has_stepper_d" type="guint"/>
+      <field name="need_recalc" type="guint"/>
+      <field name="slider_size_fixed" type="guint"/>
+      <field name="min_slider_size" type="gint"/>
+      <field name="orientation" type="GtkOrientation"/>
+      <field name="range_rect" type="GdkRectangle"/>
+      <field name="slider_start" type="gint"/>
+      <field name="slider_end" type="gint"/>
+      <field name="round_digits" type="gint"/>
+      <field name="trough_click_forward" type="guint"/>
+      <field name="update_pending" type="guint"/>
+      <field name="layout" type="GtkRangeLayout*"/>
+      <field name="timer" type="GtkRangeStepTimer*"/>
+      <field name="slide_initial_slider_position" type="gint"/>
+      <field name="slide_initial_coordinate" type="gint"/>
+      <field name="update_timeout_id" type="guint"/>
+      <field name="event_window" type="GdkWindow*"/>
+      <signal name="value_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </signal>
+      <signal name="adjust_bounds" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="new_value" type="gdouble"/>
+        </parameters>
+      </signal>
+      <signal name="move_slider" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="scroll" type="GtkScrollType"/>
+        </parameters>
+      </signal>
+      <signal name="change_value" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="scroll" type="GtkScrollType"/>
+          <parameter name="new_value" type="gdouble"/>
+        </parameters>
+      </signal>
+      <property name="update-policy" readable="1" type="GtkUpdateType" writable="1"/>
+      <property construct="1" name="adjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="inverted" readable="1" type="gboolean" writable="1"/>
+      <property name="lower-stepper-sensitivity" readable="1" type="GtkSensitivityType" writable="1"/>
+      <property name="upper-stepper-sensitivity" readable="1" type="GtkSensitivityType" writable="1"/>
+      <vfunc name="get_range_border">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="border_" type="GtkBorder*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_adjustment" symbol="gtk_range_get_adjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </method>
+      <method name="get_inverted" symbol="gtk_range_get_inverted">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </method>
+      <method name="get_lower_stepper_sensitivity" symbol="gtk_range_get_lower_stepper_sensitivity">
+        <return-type type="GtkSensitivityType"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_range_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_update_policy" symbol="gtk_range_get_update_policy">
+        <return-type type="GtkUpdateType"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </method>
+      <method name="get_upper_stepper_sensitivity" symbol="gtk_range_get_upper_stepper_sensitivity">
+        <return-type type="GtkSensitivityType"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </method>
+      <method name="get_value" symbol="gtk_range_get_value">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+        </parameters>
+      </method>
+      <method name="set_adjustment" symbol="gtk_range_set_adjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_increments" symbol="gtk_range_set_increments">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="step" type="gdouble"/>
+          <parameter name="page" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_inverted" symbol="gtk_range_set_inverted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_lower_stepper_sensitivity" symbol="gtk_range_set_lower_stepper_sensitivity">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="sensitivity" type="GtkSensitivityType"/>
+        </parameters>
+      </method>
+      <method name="set_range" symbol="gtk_range_set_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="min" type="gdouble"/>
+          <parameter name="max" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_update_policy" symbol="gtk_range_set_update_policy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="policy" type="GtkUpdateType"/>
+        </parameters>
+      </method>
+      <method name="set_upper_stepper_sensitivity" symbol="gtk_range_set_upper_stepper_sensitivity">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="sensitivity" type="GtkSensitivityType"/>
+        </parameters>
+      </method>
+      <method name="set_value" symbol="gtk_range_set_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="range" type="GtkRange*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRcStyle" parent="GObject" type-name="GtkRcStyle">
+      <field name="name" readable="1" type="gchar*" writable="1"/>
+      <field name="bg_pixmap_name" readable="1" type="gchar*" writable="1"/>
+      <field name="font_desc" readable="1" type="PangoFontDescription*" writable="1"/>
+      <field name="color_flags" readable="1" type="GtkRcFlags" writable="1"/>
+      <field name="fg" readable="1" type="GdkColor" writable="1"/>
+      <field name="bg" readable="1" type="GdkColor" writable="1"/>
+      <field name="text" readable="1" type="GdkColor" writable="1"/>
+      <field name="base" readable="1" type="GdkColor" writable="1"/>
+      <field name="xthickness" readable="1" type="gint" writable="1"/>
+      <field name="ythickness" readable="1" type="gint" writable="1"/>
+      <field name="rc_properties" type="GArray*"/>
+      <field name="rc_style_lists" type="GSList*"/>
+      <field name="icon_factories" type="GSList*"/>
+      <field name="engine_specified" type="guint"/>
+      <vfunc name="create_rc_style">
+        <return-type type="GtkRcStyle*"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="parse">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="scanner" type="GScanner*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="merge">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dest" type="GtkRcStyle*"/>
+          <parameter name="src" type="GtkRcStyle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="create_style">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+        </parameters>
+      </vfunc>
+      <method name="copy" symbol="gtk_rc_style_copy">
+        <return-type type="GtkRcStyle*"/>
+        <parameters>
+          <parameter name="orig" type="GtkRcStyle*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_rc_style_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_rc_style_new"/>
+      <method name="ref" symbol="gtk_rc_style_ref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gtk_rc_style_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRecentChooserDefault" parent="GtkVBox" type-name="GtkRecentChooserDefault">
+      <implements>
+        <interface name="GtkRecentChooser"/>
+      </implements>
+    </object>
+    <object get-type="" name="GtkRecentChooserDialog" parent="GtkDialog" type-name="GtkRecentChooserDialog">
+      <field name="priv" type="GtkRecentChooserDialogPrivate*"/>
+      <implements>
+        <interface name="GtkRecentChooser"/>
+      </implements>
+      <method name="get_type" symbol="gtk_recent_chooser_dialog_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_recent_chooser_dialog_new">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="first_button_text" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_for_manager" symbol="gtk_recent_chooser_dialog_new_for_manager">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="first_button_text" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkRecentChooserMenu" parent="GtkMenu" type-name="GtkRecentChooserMenu">
+      <field name="priv" type="GtkRecentChooserMenuPrivate*"/>
+      <property name="show-numbers" readable="1" type="gboolean" writable="1"/>
+      <vfunc name="gtk_recent1">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="gtk_recent2">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="gtk_recent3">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="gtk_recent4">
+        <return-type type="void"/>
+      </vfunc>
+      <implements>
+        <interface name="GtkRecentChooser"/>
+      </implements>
+      <method name="get_show_numbers" symbol="gtk_recent_chooser_menu_get_show_numbers">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="menu" type="GtkRecentChooserMenu*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_recent_chooser_menu_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_recent_chooser_menu_new"/>
+      <constructor name="new_for_manager" symbol="gtk_recent_chooser_menu_new_for_manager">
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+        </parameters>
+      </constructor>
+      <method name="set_show_numbers" symbol="gtk_recent_chooser_menu_set_show_numbers">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkRecentChooserMenu*"/>
+          <parameter name="show_numbers" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRecentChooserWidget" parent="GtkVBox" type-name="GtkRecentChooserWidget">
+      <field name="priv" type="GtkRecentChooserWidgetPrivate*"/>
+      <implements>
+        <interface name="GtkRecentChooser"/>
+      </implements>
+      <method name="get_type" symbol="gtk_recent_chooser_widget_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_recent_chooser_widget_new"/>
+      <constructor name="new_for_manager" symbol="gtk_recent_chooser_widget_new_for_manager">
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkRecentFilter" parent="GtkObject" type-name="GtkRecentFilter">
+      <method name="add_age" symbol="gtk_recent_filter_add_age">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="days" type="gint"/>
+        </parameters>
+      </method>
+      <method name="add_application" symbol="gtk_recent_filter_add_application">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="application" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_custom" symbol="gtk_recent_filter_add_custom">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="needed" type="GtkRecentFilterFlags"/>
+          <parameter name="func" type="GtkRecentFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="data_destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="add_group" symbol="gtk_recent_filter_add_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="group" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_mime_type" symbol="gtk_recent_filter_add_mime_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_pattern" symbol="gtk_recent_filter_add_pattern">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_pixbuf_formats" symbol="gtk_recent_filter_add_pixbuf_formats">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </method>
+      <method name="filter" symbol="gtk_recent_filter_filter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="filter_info" type="const-GtkRecentFilterInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_recent_filter_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </method>
+      <method name="get_needed" symbol="gtk_recent_filter_get_needed">
+        <return-type type="GtkRecentFilterFlags"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_recent_filter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_recent_filter_new"/>
+      <method name="set_name" symbol="gtk_recent_filter_set_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkRecentFilter*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRecentManager" parent="GObject" type-name="GtkRecentManager">
+      <field name="priv" type="GtkRecentManagerPrivate*"/>
+      <property construct-only="1" name="filename" readable="1" type="gchar*" writable="1"/>
+      <property name="limit" readable="1" type="gint" writable="1"/>
+      <property name="size" readable="1" type="gint"/>
+      <signal name="changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+        </parameters>
+      </signal>
+      <vfunc name="_gtk_recent1">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="_gtk_recent2">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="_gtk_recent3">
+        <return-type type="void"/>
+      </vfunc>
+      <vfunc name="_gtk_recent4">
+        <return-type type="void"/>
+      </vfunc>
+      <method name="add_full" symbol="gtk_recent_manager_add_full">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="recent_data" type="const-GtkRecentData*"/>
+        </parameters>
+      </method>
+      <method name="add_item" symbol="gtk_recent_manager_add_item">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="error_quark" symbol="gtk_recent_manager_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="get_default" symbol="gtk_recent_manager_get_default">
+        <return-type type="GtkRecentManager*"/>
+      </method>
+      <method name="get_for_screen" symbol="gtk_recent_manager_get_for_screen">
+        <return-type type="GtkRecentManager*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_items" symbol="gtk_recent_manager_get_items">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+        </parameters>
+      </method>
+      <method name="get_limit" symbol="gtk_recent_manager_get_limit">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_recent_manager_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="has_item" symbol="gtk_recent_manager_has_item">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="uri" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="lookup_item" symbol="gtk_recent_manager_lookup_item">
+        <return-type type="GtkRecentInfo*"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="move_item" symbol="gtk_recent_manager_move_item">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="new_uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_recent_manager_new"/>
+      <method name="purge_items" symbol="gtk_recent_manager_purge_items">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="remove_item" symbol="gtk_recent_manager_remove_item">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="uri" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_limit" symbol="gtk_recent_manager_set_limit">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="limit" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_screen" symbol="gtk_recent_manager_set_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="manager" type="GtkRecentManager*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkRuler" parent="GtkWidget" type-name="GtkRuler">
+      <field name="backing_store" type="GdkPixmap*"/>
+      <field name="non_gr_exp_gc" type="GdkGC*"/>
+      <field name="metric" type="GtkRulerMetric*"/>
+      <field name="xsrc" type="gint"/>
+      <field name="ysrc" type="gint"/>
+      <field name="slider_size" type="gint"/>
+      <field name="lower" type="gdouble"/>
+      <field name="upper" type="gdouble"/>
+      <field name="position" type="gdouble"/>
+      <field name="max_size" type="gdouble"/>
+      <property name="lower" readable="1" type="gdouble" writable="1"/>
+      <property name="upper" readable="1" type="gdouble" writable="1"/>
+      <property name="position" readable="1" type="gdouble" writable="1"/>
+      <property name="max-size" readable="1" type="gdouble" writable="1"/>
+      <property name="metric" readable="1" type="GtkMetricType" writable="1"/>
+      <vfunc name="draw_ticks">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_pos">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+        </parameters>
+      </vfunc>
+      <method name="draw_pos" symbol="gtk_ruler_draw_pos">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+        </parameters>
+      </method>
+      <method name="draw_ticks" symbol="gtk_ruler_draw_ticks">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+        </parameters>
+      </method>
+      <method name="get_metric" symbol="gtk_ruler_get_metric">
+        <return-type type="GtkMetricType"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+        </parameters>
+      </method>
+      <method name="get_range" symbol="gtk_ruler_get_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+          <parameter name="lower" type="gdouble*"/>
+          <parameter name="upper" type="gdouble*"/>
+          <parameter name="position" type="gdouble*"/>
+          <parameter name="max_size" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_ruler_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="set_metric" symbol="gtk_ruler_set_metric">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+          <parameter name="metric" type="GtkMetricType"/>
+        </parameters>
+      </method>
+      <method name="set_range" symbol="gtk_ruler_set_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="ruler" type="GtkRuler*"/>
+          <parameter name="lower" type="gdouble"/>
+          <parameter name="upper" type="gdouble"/>
+          <parameter name="position" type="gdouble"/>
+          <parameter name="max_size" type="gdouble"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkScale" parent="GtkRange" type-name="GtkScale">
+      <field name="digits" type="gint"/>
+      <field name="draw_value" type="guint"/>
+      <field name="value_pos" type="guint"/>
+      <signal name="format_value" when="LAST">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </signal>
+      <property name="digits" readable="1" type="gint" writable="1"/>
+      <property name="draw-value" readable="1" type="gboolean" writable="1"/>
+      <property name="value-pos" readable="1" type="GtkPositionType" writable="1"/>
+      <vfunc name="draw_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_layout_offsets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </vfunc>
+      <method name="get_digits" symbol="gtk_scale_get_digits">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+        </parameters>
+      </method>
+      <method name="get_draw_value" symbol="gtk_scale_get_draw_value">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+        </parameters>
+      </method>
+      <method name="get_layout" symbol="gtk_scale_get_layout">
+        <return-type type="PangoLayout*"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+        </parameters>
+      </method>
+      <method name="get_layout_offsets" symbol="gtk_scale_get_layout_offsets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_scale_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_value_pos" symbol="gtk_scale_get_value_pos">
+        <return-type type="GtkPositionType"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+        </parameters>
+      </method>
+      <method name="set_digits" symbol="gtk_scale_set_digits">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+          <parameter name="digits" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_draw_value" symbol="gtk_scale_set_draw_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+          <parameter name="draw_value" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_value_pos" symbol="gtk_scale_set_value_pos">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scale" type="GtkScale*"/>
+          <parameter name="pos" type="GtkPositionType"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkScrollbar" parent="GtkRange" type-name="GtkScrollbar">
+      <method name="get_type" symbol="gtk_scrollbar_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GtkScrolledWindow" parent="GtkBin" type-name="GtkScrolledWindow">
+      <field name="hscrollbar" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="vscrollbar" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="hscrollbar_policy" type="guint"/>
+      <field name="vscrollbar_policy" type="guint"/>
+      <field name="hscrollbar_visible" type="guint"/>
+      <field name="vscrollbar_visible" type="guint"/>
+      <field name="window_placement" type="guint"/>
+      <field name="focus_out" type="guint"/>
+      <field name="shadow_type" type="guint16"/>
+      <property construct="1" name="hadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property construct="1" name="vadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="hscrollbar-policy" readable="1" type="GtkPolicyType" writable="1"/>
+      <property name="vscrollbar-policy" readable="1" type="GtkPolicyType" writable="1"/>
+      <property name="window-placement" readable="1" type="GtkCornerType" writable="1"/>
+      <property name="window-placement-set" readable="1" type="gboolean" writable="1"/>
+      <property name="shadow-type" readable="1" type="GtkShadowType" writable="1"/>
+      <signal name="scroll_child" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="scroll" type="GtkScrollType"/>
+          <parameter name="horizontal" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="move_focus_out" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+        </parameters>
+      </signal>
+      <method name="add_with_viewport" symbol="gtk_scrolled_window_add_with_viewport">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_hadjustment" symbol="gtk_scrolled_window_get_hadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_hscrollbar" symbol="gtk_scrolled_window_get_hscrollbar">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_placement" symbol="gtk_scrolled_window_get_placement">
+        <return-type type="GtkCornerType"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_policy" symbol="gtk_scrolled_window_get_policy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="hscrollbar_policy" type="GtkPolicyType*"/>
+          <parameter name="vscrollbar_policy" type="GtkPolicyType*"/>
+        </parameters>
+      </method>
+      <method name="get_shadow_type" symbol="gtk_scrolled_window_get_shadow_type">
+        <return-type type="GtkShadowType"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_scrolled_window_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_vadjustment" symbol="gtk_scrolled_window_get_vadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_vscrollbar" symbol="gtk_scrolled_window_get_vscrollbar">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_scrolled_window_new">
+        <parameters>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+      <method name="set_hadjustment" symbol="gtk_scrolled_window_set_hadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_placement" symbol="gtk_scrolled_window_set_placement">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="window_placement" type="GtkCornerType"/>
+        </parameters>
+      </method>
+      <method name="set_policy" symbol="gtk_scrolled_window_set_policy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="hscrollbar_policy" type="GtkPolicyType"/>
+          <parameter name="vscrollbar_policy" type="GtkPolicyType"/>
+        </parameters>
+      </method>
+      <method name="set_shadow_type" symbol="gtk_scrolled_window_set_shadow_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="type" type="GtkShadowType"/>
+        </parameters>
+      </method>
+      <method name="set_vadjustment" symbol="gtk_scrolled_window_set_vadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="unset_placement" symbol="gtk_scrolled_window_unset_placement">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="scrolled_window" type="GtkScrolledWindow*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkSeparator" parent="GtkWidget" type-name="GtkSeparator">
+      <method name="get_type" symbol="gtk_separator_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GtkSeparatorMenuItem" parent="GtkMenuItem" type-name="GtkSeparatorMenuItem">
+      <method name="get_type" symbol="gtk_separator_menu_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_separator_menu_item_new"/>
+    </object>
+    <object get-type="" name="GtkSeparatorToolItem" parent="GtkToolItem" type-name="GtkSeparatorToolItem">
+      <field name="priv" type="GtkSeparatorToolItemPrivate*"/>
+      <property name="draw" readable="1" type="gboolean" writable="1"/>
+      <method name="get_draw" symbol="gtk_separator_tool_item_get_draw">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="item" type="GtkSeparatorToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_separator_tool_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_separator_tool_item_new"/>
+      <method name="set_draw" symbol="gtk_separator_tool_item_set_draw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkSeparatorToolItem*"/>
+          <parameter name="draw" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkSettings" parent="GObject" type-name="GtkSettings">
+      <field name="queued_settings" type="GData*"/>
+      <field name="property_values" type="GtkSettingsPropertyValue*"/>
+      <field name="rc_context" type="GtkRcContext*"/>
+      <field name="screen" type="GdkScreen*"/>
+      <property name="color-hash" readable="1" type="GHashTable"/>
+      <method name="get_default" symbol="gtk_settings_get_default">
+        <return-type type="GtkSettings*"/>
+      </method>
+      <method name="get_for_screen" symbol="gtk_settings_get_for_screen">
+        <return-type type="GtkSettings*"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_settings_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="install_property" symbol="gtk_settings_install_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pspec" type="GParamSpec*"/>
+        </parameters>
+      </method>
+      <method name="install_property_parser" symbol="gtk_settings_install_property_parser">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="pspec" type="GParamSpec*"/>
+          <parameter name="parser" type="GtkRcPropertyParser"/>
+        </parameters>
+      </method>
+      <method name="set_double_property" symbol="gtk_settings_set_double_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="v_double" type="gdouble"/>
+          <parameter name="origin" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_long_property" symbol="gtk_settings_set_long_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="v_long" type="glong"/>
+          <parameter name="origin" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_property_value" symbol="gtk_settings_set_property_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="svalue" type="const-GtkSettingsValue*"/>
+        </parameters>
+      </method>
+      <method name="set_string_property" symbol="gtk_settings_set_string_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="v_string" type="const-gchar*"/>
+          <parameter name="origin" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkSizeGroup" parent="GObject" type-name="GtkSizeGroup">
+      <field name="widgets" type="GSList*"/>
+      <field name="mode" type="guint8"/>
+      <field name="have_width" type="guint"/>
+      <field name="have_height" type="guint"/>
+      <field name="ignore_hidden" type="guint"/>
+      <field name="requisition" type="GtkRequisition"/>
+      <property name="mode" readable="1" type="GtkSizeGroupMode" writable="1"/>
+      <property name="ignore-hidden" readable="1" type="gboolean" writable="1"/>
+      <method name="add_widget" symbol="gtk_size_group_add_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_ignore_hidden" symbol="gtk_size_group_get_ignore_hidden">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+        </parameters>
+      </method>
+      <method name="get_mode" symbol="gtk_size_group_get_mode">
+        <return-type type="GtkSizeGroupMode"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_size_group_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_widgets" symbol="gtk_size_group_get_widgets">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_size_group_new">
+        <parameters>
+          <parameter name="mode" type="GtkSizeGroupMode"/>
+        </parameters>
+      </constructor>
+      <method name="remove_widget" symbol="gtk_size_group_remove_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_ignore_hidden" symbol="gtk_size_group_set_ignore_hidden">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+          <parameter name="ignore_hidden" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_mode" symbol="gtk_size_group_set_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="size_group" type="GtkSizeGroup*"/>
+          <parameter name="mode" type="GtkSizeGroupMode"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkSocket" parent="GtkContainer" type-name="GtkSocket">
+      <field name="request_width" type="guint16"/>
+      <field name="request_height" type="guint16"/>
+      <field name="current_width" type="guint16"/>
+      <field name="current_height" type="guint16"/>
+      <field name="plug_window" type="GdkWindow*"/>
+      <field name="plug_widget" type="GtkWidget*"/>
+      <field name="xembed_version" type="gshort"/>
+      <field name="same_app" type="guint"/>
+      <field name="focus_in" type="guint"/>
+      <field name="have_size" type="guint"/>
+      <field name="need_map" type="guint"/>
+      <field name="is_mapped" type="guint"/>
+      <field name="active" type="guint"/>
+      <field name="accel_group" type="GtkAccelGroup*"/>
+      <field name="toplevel" type="GtkWidget*"/>
+      <signal name="plug_added" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="socket_" type="GtkSocket*"/>
+        </parameters>
+      </signal>
+      <signal name="plug_removed" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="socket_" type="GtkSocket*"/>
+        </parameters>
+      </signal>
+      <method name="add_id" symbol="gtk_socket_add_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="socket_" type="GtkSocket*"/>
+          <parameter name="window_id" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+      <method name="get_id" symbol="gtk_socket_get_id">
+        <return-type type="GdkNativeWindow"/>
+        <parameters>
+          <parameter name="socket_" type="GtkSocket*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_socket_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_socket_new"/>
+      <method deprecated="1" name="steal" symbol="gtk_socket_steal">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="socket_" type="GtkSocket*"/>
+          <parameter name="wid" type="GdkNativeWindow"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkSpinButton" parent="GtkEntry" type-name="GtkSpinButton">
+      <field name="adjustment" type="GtkAdjustment*"/>
+      <field name="panel" type="GdkWindow*"/>
+      <field name="timer" type="guint32"/>
+      <field name="climb_rate" type="gdouble"/>
+      <field name="timer_step" type="gdouble"/>
+      <field name="update_policy" type="GtkSpinButtonUpdatePolicy"/>
+      <field name="in_child" type="guint"/>
+      <field name="click_child" type="guint"/>
+      <field name="button" type="guint"/>
+      <field name="need_timer" type="guint"/>
+      <field name="timer_calls" type="guint"/>
+      <field name="digits" type="guint"/>
+      <field name="numeric" type="guint"/>
+      <field name="wrap" type="guint"/>
+      <field name="snap_to_ticks" type="guint"/>
+      <property name="adjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="climb-rate" readable="1" type="gdouble" writable="1"/>
+      <property name="digits" readable="1" type="guint" writable="1"/>
+      <property name="snap-to-ticks" readable="1" type="gboolean" writable="1"/>
+      <property name="numeric" readable="1" type="gboolean" writable="1"/>
+      <property name="wrap" readable="1" type="gboolean" writable="1"/>
+      <property name="update-policy" readable="1" type="GtkSpinButtonUpdatePolicy" writable="1"/>
+      <property name="value" readable="1" type="gdouble" writable="1"/>
+      <signal name="input" when="LAST">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="new_value" type="gdouble*"/>
+        </parameters>
+      </signal>
+      <signal name="output" when="LAST">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </signal>
+      <signal name="value_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </signal>
+      <signal name="wrapped" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </signal>
+      <signal name="change_value" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="scroll" type="GtkScrollType"/>
+        </parameters>
+      </signal>
+      <implements>
+        <interface name="GtkEditable"/>
+      </implements>
+      <method name="configure" symbol="gtk_spin_button_configure">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+          <parameter name="climb_rate" type="gdouble"/>
+          <parameter name="digits" type="guint"/>
+        </parameters>
+      </method>
+      <method name="get_adjustment" symbol="gtk_spin_button_get_adjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_digits" symbol="gtk_spin_button_get_digits">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_increments" symbol="gtk_spin_button_get_increments">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="step" type="gdouble*"/>
+          <parameter name="page" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_numeric" symbol="gtk_spin_button_get_numeric">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_range" symbol="gtk_spin_button_get_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="min" type="gdouble*"/>
+          <parameter name="max" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="get_snap_to_ticks" symbol="gtk_spin_button_get_snap_to_ticks">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_spin_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_update_policy" symbol="gtk_spin_button_get_update_policy">
+        <return-type type="GtkSpinButtonUpdatePolicy"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_value" symbol="gtk_spin_button_get_value">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_value_as_int" symbol="gtk_spin_button_get_value_as_int">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <method name="get_wrap" symbol="gtk_spin_button_get_wrap">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_spin_button_new">
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+          <parameter name="climb_rate" type="gdouble"/>
+          <parameter name="digits" type="guint"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_range" symbol="gtk_spin_button_new_with_range">
+        <parameters>
+          <parameter name="min" type="gdouble"/>
+          <parameter name="max" type="gdouble"/>
+          <parameter name="step" type="gdouble"/>
+        </parameters>
+      </constructor>
+      <method name="set_adjustment" symbol="gtk_spin_button_set_adjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_digits" symbol="gtk_spin_button_set_digits">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="digits" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_increments" symbol="gtk_spin_button_set_increments">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="step" type="gdouble"/>
+          <parameter name="page" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_numeric" symbol="gtk_spin_button_set_numeric">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="numeric" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_range" symbol="gtk_spin_button_set_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="min" type="gdouble"/>
+          <parameter name="max" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_snap_to_ticks" symbol="gtk_spin_button_set_snap_to_ticks">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="snap_to_ticks" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_update_policy" symbol="gtk_spin_button_set_update_policy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="policy" type="GtkSpinButtonUpdatePolicy"/>
+        </parameters>
+      </method>
+      <method name="set_value" symbol="gtk_spin_button_set_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="value" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_wrap" symbol="gtk_spin_button_set_wrap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="wrap" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="spin" symbol="gtk_spin_button_spin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+          <parameter name="direction" type="GtkSpinType"/>
+          <parameter name="increment" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="update" symbol="gtk_spin_button_update">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spin_button" type="GtkSpinButton*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkStatusbar" parent="GtkHBox" type-name="GtkStatusbar">
+      <field name="frame" type="GtkWidget*"/>
+      <field name="label" type="GtkWidget*"/>
+      <field name="messages" type="GSList*"/>
+      <field name="keys" type="GSList*"/>
+      <field name="seq_context_id" type="guint"/>
+      <field name="seq_message_id" type="guint"/>
+      <field name="grip_window" type="GdkWindow*"/>
+      <field name="has_resize_grip" type="guint"/>
+      <property name="has-resize-grip" readable="1" type="gboolean" writable="1"/>
+      <signal name="text_pushed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="context_id" type="guint"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <signal name="text_popped" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="context_id" type="guint"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <method name="get_context_id" symbol="gtk_statusbar_get_context_id">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="context_description" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_has_resize_grip" symbol="gtk_statusbar_get_has_resize_grip">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_statusbar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_statusbar_new"/>
+      <method name="pop" symbol="gtk_statusbar_pop">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="context_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="push" symbol="gtk_statusbar_push">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="context_id" type="guint"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_statusbar_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="context_id" type="guint"/>
+          <parameter name="message_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_has_resize_grip" symbol="gtk_statusbar_set_has_resize_grip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="statusbar" type="GtkStatusbar*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkStatusIcon" parent="GObject" type-name="GtkStatusIcon">
+      <field name="priv" type="GtkStatusIconPrivate*"/>
+      <property name="pixbuf" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="file" type="gchar*" writable="1"/>
+      <property name="stock" readable="1" type="gchar*" writable="1"/>
+      <property name="icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="storage-type" readable="1" type="GtkImageType"/>
+      <property name="size" readable="1" type="gint"/>
+      <property name="blinking" readable="1" type="gboolean" writable="1"/>
+      <property name="visible" readable="1" type="gboolean" writable="1"/>
+      <signal name="activate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </signal>
+      <signal name="popup_menu" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="button" type="guint"/>
+          <parameter name="activate_time" type="guint32"/>
+        </parameters>
+      </signal>
+      <signal name="size_changed" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="size" type="gint"/>
+        </parameters>
+      </signal>
+      <method name="get_blinking" symbol="gtk_status_icon_get_blinking">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="get_geometry" symbol="gtk_status_icon_get_geometry">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="screen" type="GdkScreen**"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="orientation" type="GtkOrientation*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_name" symbol="gtk_status_icon_get_icon_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gtk_status_icon_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gtk_status_icon_get_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="get_stock" symbol="gtk_status_icon_get_stock">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="get_storage_type" symbol="gtk_status_icon_get_storage_type">
+        <return-type type="GtkImageType"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_status_icon_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible" symbol="gtk_status_icon_get_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <method name="is_embedded" symbol="gtk_status_icon_is_embedded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_status_icon_new"/>
+      <constructor name="new_from_file" symbol="gtk_status_icon_new_from_file">
+        <parameters>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_icon_name" symbol="gtk_status_icon_new_from_icon_name">
+        <parameters>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_pixbuf" symbol="gtk_status_icon_new_from_pixbuf">
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_stock" symbol="gtk_status_icon_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="position_menu" symbol="gtk_status_icon_position_menu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="menu" type="GtkMenu*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="push_in" type="gboolean*"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="set_blinking" symbol="gtk_status_icon_set_blinking">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="blinking" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_from_file" symbol="gtk_status_icon_set_from_file">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_from_icon_name" symbol="gtk_status_icon_set_from_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_from_pixbuf" symbol="gtk_status_icon_set_from_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_from_stock" symbol="gtk_status_icon_set_from_stock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_tooltip" symbol="gtk_status_icon_set_tooltip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="tooltip_text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_visible" symbol="gtk_status_icon_set_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="status_icon" type="GtkStatusIcon*"/>
+          <parameter name="visible" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkStyle" parent="GObject" type-name="GtkStyle">
+      <field name="fg" readable="1" type="GdkColor" writable="1"/>
+      <field name="bg" readable="1" type="GdkColor" writable="1"/>
+      <field name="light" readable="1" type="GdkColor" writable="1"/>
+      <field name="dark" readable="1" type="GdkColor" writable="1"/>
+      <field name="mid" readable="1" type="GdkColor" writable="1"/>
+      <field name="text" readable="1" type="GdkColor" writable="1"/>
+      <field name="base" readable="1" type="GdkColor" writable="1"/>
+      <field name="text_aa" readable="1" type="GdkColor" writable="1"/>
+      <field name="black" readable="1" type="GdkColor" writable="1"/>
+      <field name="white" readable="1" type="GdkColor" writable="1"/>
+      <field name="font_desc" readable="1" type="PangoFontDescription*" writable="1"/>
+      <field name="xthickness" readable="1" type="gint" writable="1"/>
+      <field name="ythickness" readable="1" type="gint" writable="1"/>
+      <field name="fg_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="bg_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="light_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="dark_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="mid_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="text_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="base_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="text_aa_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="black_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="white_gc" readable="1" type="GdkGC*" writable="1"/>
+      <field name="bg_pixmap" readable="1" type="GdkPixmap*" writable="1"/>
+      <field name="attach_count" type="gint"/>
+      <field name="depth" type="gint"/>
+      <field name="colormap" type="GdkColormap*"/>
+      <field name="private_font" type="GdkFont*"/>
+      <field name="private_font_desc" type="PangoFontDescription*"/>
+      <field name="rc_style" type="GtkRcStyle*"/>
+      <field name="styles" type="GSList*"/>
+      <field name="property_cache" type="GArray*"/>
+      <field name="icon_factories" type="GSList*"/>
+      <signal name="realize" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </signal>
+      <signal name="unrealize" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </signal>
+      <vfunc name="copy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="src" type="GtkStyle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="clone">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="init_from_rc">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="set_background">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="render_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="source" type="const-GtkIconSource*"/>
+          <parameter name="direction" type="GtkTextDirection"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="size" type="GtkIconSize"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_hline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x1" type="gint"/>
+          <parameter name="x2" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_vline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="y1_" type="gint"/>
+          <parameter name="y2_" type="gint"/>
+          <parameter name="x" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_shadow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_polygon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="point" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+          <parameter name="fill" type="gboolean"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_arrow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="arrow_type" type="GtkArrowType"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_diamond">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_box">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_flat_box">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_check">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_option">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_shadow_gap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+          <parameter name="gap_x" type="gint"/>
+          <parameter name="gap_width" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_box_gap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+          <parameter name="gap_x" type="gint"/>
+          <parameter name="gap_width" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_extension">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_slider">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_handle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_expander">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="expander_style" type="GtkExpanderStyle"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_layout">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="use_text" type="gboolean"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_resize_grip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="edge" type="GdkWindowEdge"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </vfunc>
+      <method name="apply_default_background" symbol="gtk_style_apply_default_background">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="set_bg" type="gboolean"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="attach" symbol="gtk_style_attach">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="gtk_style_copy">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </method>
+      <method name="detach" symbol="gtk_style_detach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="get_font" symbol="gtk_style_get_font">
+        <return-type type="GdkFont*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_style_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="lookup_color" symbol="gtk_style_lookup_color">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="color_name" type="const-gchar*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="lookup_icon_set" symbol="gtk_style_lookup_icon_set">
+        <return-type type="GtkIconSet*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_style_new"/>
+      <method deprecated="1" name="ref" symbol="gtk_style_ref">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </method>
+      <method name="render_icon" symbol="gtk_style_render_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="source" type="const-GtkIconSource*"/>
+          <parameter name="direction" type="GtkTextDirection"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="size" type="GtkIconSize"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_background" symbol="gtk_style_set_background">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_font" symbol="gtk_style_set_font">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="font" type="GdkFont*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unref" symbol="gtk_style_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTable" parent="GtkContainer" type-name="GtkTable">
+      <field name="children" type="GList*"/>
+      <field name="rows" type="GtkTableRowCol*"/>
+      <field name="cols" type="GtkTableRowCol*"/>
+      <field name="nrows" type="guint16"/>
+      <field name="ncols" type="guint16"/>
+      <field name="column_spacing" type="guint16"/>
+      <field name="row_spacing" type="guint16"/>
+      <field name="homogeneous" type="guint"/>
+      <property name="n-rows" readable="1" type="guint" writable="1"/>
+      <property name="n-columns" readable="1" type="guint" writable="1"/>
+      <property name="row-spacing" readable="1" type="guint" writable="1"/>
+      <property name="column-spacing" readable="1" type="guint" writable="1"/>
+      <property name="homogeneous" readable="1" type="gboolean" writable="1"/>
+      <method name="attach" symbol="gtk_table_attach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="left_attach" type="guint"/>
+          <parameter name="right_attach" type="guint"/>
+          <parameter name="top_attach" type="guint"/>
+          <parameter name="bottom_attach" type="guint"/>
+          <parameter name="xoptions" type="GtkAttachOptions"/>
+          <parameter name="yoptions" type="GtkAttachOptions"/>
+          <parameter name="xpadding" type="guint"/>
+          <parameter name="ypadding" type="guint"/>
+        </parameters>
+      </method>
+      <method name="attach_defaults" symbol="gtk_table_attach_defaults">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="left_attach" type="guint"/>
+          <parameter name="right_attach" type="guint"/>
+          <parameter name="top_attach" type="guint"/>
+          <parameter name="bottom_attach" type="guint"/>
+        </parameters>
+      </method>
+      <method name="get_col_spacing" symbol="gtk_table_get_col_spacing">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="column" type="guint"/>
+        </parameters>
+      </method>
+      <method name="get_default_col_spacing" symbol="gtk_table_get_default_col_spacing">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_default_row_spacing" symbol="gtk_table_get_default_row_spacing">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_homogeneous" symbol="gtk_table_get_homogeneous">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+        </parameters>
+      </method>
+      <method name="get_row_spacing" symbol="gtk_table_get_row_spacing">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="row" type="guint"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_table_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_table_new">
+        <parameters>
+          <parameter name="rows" type="guint"/>
+          <parameter name="columns" type="guint"/>
+          <parameter name="homogeneous" type="gboolean"/>
+        </parameters>
+      </constructor>
+      <method name="resize" symbol="gtk_table_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="rows" type="guint"/>
+          <parameter name="columns" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_col_spacing" symbol="gtk_table_set_col_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="column" type="guint"/>
+          <parameter name="spacing" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_col_spacings" symbol="gtk_table_set_col_spacings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="spacing" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_homogeneous" symbol="gtk_table_set_homogeneous">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="homogeneous" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_row_spacing" symbol="gtk_table_set_row_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="row" type="guint"/>
+          <parameter name="spacing" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_row_spacings" symbol="gtk_table_set_row_spacings">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTable*"/>
+          <parameter name="spacing" type="guint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTearoffMenuItem" parent="GtkMenuItem" type-name="GtkTearoffMenuItem">
+      <field name="torn_off" type="guint"/>
+      <method name="get_type" symbol="gtk_tearoff_menu_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_tearoff_menu_item_new"/>
+    </object>
+    <object get-type="" name="GtkTextBuffer" parent="GObject" type-name="GtkTextBuffer">
+      <field name="tag_table" type="GtkTextTagTable*"/>
+      <field name="btree" type="GtkTextBTree*"/>
+      <field name="clipboard_contents_buffers" type="GSList*"/>
+      <field name="selection_clipboards" type="GSList*"/>
+      <field name="log_attr_cache" type="GtkTextLogAttrCache*"/>
+      <field name="user_action_count" type="guint"/>
+      <field name="modified" type="guint"/>
+      <field name="has_selection" type="guint"/>
+      <property construct-only="1" name="tag-table" readable="1" type="GtkTextTagTable" writable="1"/>
+      <property name="text" readable="1" type="gchar*" writable="1"/>
+      <property name="has-selection" readable="1" type="gboolean"/>
+      <property name="cursor-position" readable="1" type="gint"/>
+      <property name="copy-target-list" readable="1" type="GtkTargetList"/>
+      <property name="paste-target-list" readable="1" type="GtkTargetList"/>
+      <signal name="insert_text" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="pos" type="GtkTextIter*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="insert_pixbuf" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="pos" type="GtkTextIter*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </signal>
+      <signal name="insert_child_anchor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="pos" type="GtkTextIter*"/>
+          <parameter name="anchor" type="GtkTextChildAnchor*"/>
+        </parameters>
+      </signal>
+      <signal name="delete_range" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="GtkTextIter*"/>
+          <parameter name="end" type="GtkTextIter*"/>
+        </parameters>
+      </signal>
+      <signal name="changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </signal>
+      <signal name="modified_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </signal>
+      <signal name="mark_set" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="location" type="const-GtkTextIter*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </signal>
+      <signal name="mark_deleted" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </signal>
+      <signal name="apply_tag" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="start_char" type="const-GtkTextIter*"/>
+          <parameter name="end_char" type="const-GtkTextIter*"/>
+        </parameters>
+      </signal>
+      <signal name="remove_tag" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="start_char" type="const-GtkTextIter*"/>
+          <parameter name="end_char" type="const-GtkTextIter*"/>
+        </parameters>
+      </signal>
+      <signal name="begin_user_action" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </signal>
+      <signal name="end_user_action" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </signal>
+      <method name="add_selection_clipboard" symbol="gtk_text_buffer_add_selection_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="apply_tag" symbol="gtk_text_buffer_apply_tag">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="apply_tag_by_name" symbol="gtk_text_buffer_apply_tag_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backspace" symbol="gtk_text_buffer_backspace">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="interactive" type="gboolean"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="begin_user_action" symbol="gtk_text_buffer_begin_user_action">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="copy_clipboard" symbol="gtk_text_buffer_copy_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="create_child_anchor" symbol="gtk_text_buffer_create_child_anchor">
+        <return-type type="GtkTextChildAnchor*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="create_mark" symbol="gtk_text_buffer_create_mark">
+        <return-type type="GtkTextMark*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="mark_name" type="const-gchar*"/>
+          <parameter name="where" type="const-GtkTextIter*"/>
+          <parameter name="left_gravity" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="create_tag" symbol="gtk_text_buffer_create_tag">
+        <return-type type="GtkTextTag*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tag_name" type="const-gchar*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="cut_clipboard" symbol="gtk_text_buffer_cut_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="delete" symbol="gtk_text_buffer_delete">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="GtkTextIter*"/>
+          <parameter name="end" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="delete_interactive" symbol="gtk_text_buffer_delete_interactive">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start_iter" type="GtkTextIter*"/>
+          <parameter name="end_iter" type="GtkTextIter*"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="delete_mark" symbol="gtk_text_buffer_delete_mark">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="delete_mark_by_name" symbol="gtk_text_buffer_delete_mark_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="delete_selection" symbol="gtk_text_buffer_delete_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="interactive" type="gboolean"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="deserialize" symbol="gtk_text_buffer_deserialize">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="register_buffer" type="GtkTextBuffer*"/>
+          <parameter name="content_buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="data" type="const-guint8*"/>
+          <parameter name="length" type="gsize"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="deserialize_get_can_create_tags" symbol="gtk_text_buffer_deserialize_get_can_create_tags">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="deserialize_set_can_create_tags" symbol="gtk_text_buffer_deserialize_set_can_create_tags">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom"/>
+          <parameter name="can_create_tags" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="end_user_action" symbol="gtk_text_buffer_end_user_action">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_bounds" symbol="gtk_text_buffer_get_bounds">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="GtkTextIter*"/>
+          <parameter name="end" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_char_count" symbol="gtk_text_buffer_get_char_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_copy_target_list" symbol="gtk_text_buffer_get_copy_target_list">
+        <return-type type="GtkTargetList*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_deserialize_formats" symbol="gtk_text_buffer_get_deserialize_formats">
+        <return-type type="GdkAtom*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="n_formats" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_end_iter" symbol="gtk_text_buffer_get_end_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_has_selection" symbol="gtk_text_buffer_get_has_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_insert" symbol="gtk_text_buffer_get_insert">
+        <return-type type="GtkTextMark*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_child_anchor" symbol="gtk_text_buffer_get_iter_at_child_anchor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="anchor" type="GtkTextChildAnchor*"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_line" symbol="gtk_text_buffer_get_iter_at_line">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="line_number" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_line_index" symbol="gtk_text_buffer_get_iter_at_line_index">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="line_number" type="gint"/>
+          <parameter name="byte_index" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_line_offset" symbol="gtk_text_buffer_get_iter_at_line_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="line_number" type="gint"/>
+          <parameter name="char_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_mark" symbol="gtk_text_buffer_get_iter_at_mark">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_offset" symbol="gtk_text_buffer_get_iter_at_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="char_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_line_count" symbol="gtk_text_buffer_get_line_count">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_mark" symbol="gtk_text_buffer_get_mark">
+        <return-type type="GtkTextMark*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_modified" symbol="gtk_text_buffer_get_modified">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_paste_target_list" symbol="gtk_text_buffer_get_paste_target_list">
+        <return-type type="GtkTargetList*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_selection_bound" symbol="gtk_text_buffer_get_selection_bound">
+        <return-type type="GtkTextMark*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_selection_bounds" symbol="gtk_text_buffer_get_selection_bounds">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="GtkTextIter*"/>
+          <parameter name="end" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_serialize_formats" symbol="gtk_text_buffer_get_serialize_formats">
+        <return-type type="GdkAtom*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="n_formats" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_slice" symbol="gtk_text_buffer_get_slice">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+          <parameter name="include_hidden_chars" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="get_start_iter" symbol="gtk_text_buffer_get_start_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_tag_table" symbol="gtk_text_buffer_get_tag_table">
+        <return-type type="GtkTextTagTable*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="gtk_text_buffer_get_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+          <parameter name="include_hidden_chars" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_buffer_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert" symbol="gtk_text_buffer_insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_at_cursor" symbol="gtk_text_buffer_insert_at_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_child_anchor" symbol="gtk_text_buffer_insert_child_anchor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="anchor" type="GtkTextChildAnchor*"/>
+        </parameters>
+      </method>
+      <method name="insert_interactive" symbol="gtk_text_buffer_insert_interactive">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="insert_interactive_at_cursor" symbol="gtk_text_buffer_insert_interactive_at_cursor">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="insert_pixbuf" symbol="gtk_text_buffer_insert_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="insert_range" symbol="gtk_text_buffer_insert_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="insert_range_interactive" symbol="gtk_text_buffer_insert_range_interactive">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="insert_with_tags" symbol="gtk_text_buffer_insert_with_tags">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+          <parameter name="first_tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="insert_with_tags_by_name" symbol="gtk_text_buffer_insert_with_tags_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+          <parameter name="first_tag_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="move_mark" symbol="gtk_text_buffer_move_mark">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+          <parameter name="where" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="move_mark_by_name" symbol="gtk_text_buffer_move_mark_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="where" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_text_buffer_new">
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+        </parameters>
+      </constructor>
+      <method name="paste_clipboard" symbol="gtk_text_buffer_paste_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+          <parameter name="override_location" type="GtkTextIter*"/>
+          <parameter name="default_editable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="place_cursor" symbol="gtk_text_buffer_place_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="where" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="register_deserialize_format" symbol="gtk_text_buffer_register_deserialize_format">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+          <parameter name="function" type="GtkTextBufferDeserializeFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="user_data_destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="register_deserialize_tagset" symbol="gtk_text_buffer_register_deserialize_tagset">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tagset_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="register_serialize_format" symbol="gtk_text_buffer_register_serialize_format">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="mime_type" type="const-gchar*"/>
+          <parameter name="function" type="GtkTextBufferSerializeFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="user_data_destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="register_serialize_tagset" symbol="gtk_text_buffer_register_serialize_tagset">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tagset_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="remove_all_tags" symbol="gtk_text_buffer_remove_all_tags">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="remove_selection_clipboard" symbol="gtk_text_buffer_remove_selection_clipboard">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="clipboard" type="GtkClipboard*"/>
+        </parameters>
+      </method>
+      <method name="remove_tag" symbol="gtk_text_buffer_remove_tag">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="remove_tag_by_name" symbol="gtk_text_buffer_remove_tag_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="select_range" symbol="gtk_text_buffer_select_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="ins" type="const-GtkTextIter*"/>
+          <parameter name="bound" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="serialize" symbol="gtk_text_buffer_serialize">
+        <return-type type="guint8*"/>
+        <parameters>
+          <parameter name="register_buffer" type="GtkTextBuffer*"/>
+          <parameter name="content_buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+          <parameter name="length" type="gsize*"/>
+        </parameters>
+      </method>
+      <method name="set_modified" symbol="gtk_text_buffer_set_modified">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="gtk_text_buffer_set_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="unregister_deserialize_format" symbol="gtk_text_buffer_unregister_deserialize_format">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="unregister_serialize_format" symbol="gtk_text_buffer_unregister_serialize_format">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+          <parameter name="format" type="GdkAtom"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTextChildAnchor" parent="GObject" type-name="GtkTextChildAnchor">
+      <field name="segment" type="gpointer"/>
+      <method name="get_deleted" symbol="gtk_text_child_anchor_get_deleted">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="anchor" type="GtkTextChildAnchor*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_child_anchor_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_widgets" symbol="gtk_text_child_anchor_get_widgets">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="anchor" type="GtkTextChildAnchor*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_text_child_anchor_new"/>
+    </object>
+    <object get-type="" name="GtkTextMark" parent="GObject" type-name="GtkTextMark">
+      <field name="segment" type="gpointer"/>
+      <method name="get_buffer" symbol="gtk_text_mark_get_buffer">
+        <return-type type="GtkTextBuffer*"/>
+        <parameters>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="get_deleted" symbol="gtk_text_mark_get_deleted">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="get_left_gravity" symbol="gtk_text_mark_get_left_gravity">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_text_mark_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_mark_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible" symbol="gtk_text_mark_get_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="set_visible" symbol="gtk_text_mark_set_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="mark" type="GtkTextMark*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTextTag" parent="GObject" type-name="GtkTextTag">
+      <field name="table" type="GtkTextTagTable*"/>
+      <field name="name" type="char*"/>
+      <field name="priority" type="int"/>
+      <field name="values" type="GtkTextAttributes*"/>
+      <field name="bg_color_set" type="guint"/>
+      <field name="bg_stipple_set" type="guint"/>
+      <field name="fg_color_set" type="guint"/>
+      <field name="scale_set" type="guint"/>
+      <field name="fg_stipple_set" type="guint"/>
+      <field name="justification_set" type="guint"/>
+      <field name="left_margin_set" type="guint"/>
+      <field name="indent_set" type="guint"/>
+      <field name="rise_set" type="guint"/>
+      <field name="strikethrough_set" type="guint"/>
+      <field name="right_margin_set" type="guint"/>
+      <field name="pixels_above_lines_set" type="guint"/>
+      <field name="pixels_below_lines_set" type="guint"/>
+      <field name="pixels_inside_wrap_set" type="guint"/>
+      <field name="tabs_set" type="guint"/>
+      <field name="underline_set" type="guint"/>
+      <field name="wrap_mode_set" type="guint"/>
+      <field name="bg_full_height_set" type="guint"/>
+      <field name="invisible_set" type="guint"/>
+      <field name="editable_set" type="guint"/>
+      <field name="language_set" type="guint"/>
+      <field name="pg_bg_color_set" type="guint"/>
+      <field name="pad1" type="guint"/>
+      <field name="pad2" type="guint"/>
+      <property construct-only="1" name="name" readable="1" type="gchar*" writable="1"/>
+      <property name="background" type="gchar*" writable="1"/>
+      <property name="background-gdk" readable="1" type="GdkColor" writable="1"/>
+      <property name="background-full-height" readable="1" type="gboolean" writable="1"/>
+      <property name="background-stipple" readable="1" type="GdkPixmap" writable="1"/>
+      <property name="foreground" type="gchar*" writable="1"/>
+      <property name="foreground-gdk" readable="1" type="GdkColor" writable="1"/>
+      <property name="foreground-stipple" readable="1" type="GdkPixmap" writable="1"/>
+      <property name="direction" readable="1" type="GtkTextDirection" writable="1"/>
+      <property name="editable" readable="1" type="gboolean" writable="1"/>
+      <property name="font" readable="1" type="gchar*" writable="1"/>
+      <property name="font-desc" readable="1" type="PangoFontDescription" writable="1"/>
+      <property name="family" readable="1" type="gchar*" writable="1"/>
+      <property name="style" readable="1" type="PangoStyle" writable="1"/>
+      <property name="variant" readable="1" type="PangoVariant" writable="1"/>
+      <property name="weight" readable="1" type="gint" writable="1"/>
+      <property name="stretch" readable="1" type="PangoStretch" writable="1"/>
+      <property name="size" readable="1" type="gint" writable="1"/>
+      <property name="scale" readable="1" type="gdouble" writable="1"/>
+      <property name="size-points" readable="1" type="gdouble" writable="1"/>
+      <property name="justification" readable="1" type="GtkJustification" writable="1"/>
+      <property name="language" readable="1" type="gchar*" writable="1"/>
+      <property name="left-margin" readable="1" type="gint" writable="1"/>
+      <property name="right-margin" readable="1" type="gint" writable="1"/>
+      <property name="indent" readable="1" type="gint" writable="1"/>
+      <property name="rise" readable="1" type="gint" writable="1"/>
+      <property name="pixels-above-lines" readable="1" type="gint" writable="1"/>
+      <property name="pixels-below-lines" readable="1" type="gint" writable="1"/>
+      <property name="pixels-inside-wrap" readable="1" type="gint" writable="1"/>
+      <property name="strikethrough" readable="1" type="gboolean" writable="1"/>
+      <property name="underline" readable="1" type="PangoUnderline" writable="1"/>
+      <property name="wrap-mode" readable="1" type="GtkWrapMode" writable="1"/>
+      <property name="tabs" readable="1" type="PangoTabArray" writable="1"/>
+      <property name="invisible" readable="1" type="gboolean" writable="1"/>
+      <property name="paragraph-background" type="gchar*" writable="1"/>
+      <property name="paragraph-background-gdk" readable="1" type="GdkColor" writable="1"/>
+      <signal name="event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="event_object" type="GObject*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </signal>
+      <method name="event" symbol="gtk_text_tag_event">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="event_object" type="GObject*"/>
+          <parameter name="event" type="GdkEvent*"/>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_priority" symbol="gtk_text_tag_get_priority">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_tag_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_text_tag_new">
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_priority" symbol="gtk_text_tag_set_priority">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="priority" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTextTagTable" parent="GObject" type-name="GtkTextTagTable">
+      <field name="hash" type="GHashTable*"/>
+      <field name="anonymous" type="GSList*"/>
+      <field name="anon_count" type="gint"/>
+      <field name="buffers" type="GSList*"/>
+      <signal name="tag_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+          <parameter name="size_changed" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="tag_added" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </signal>
+      <signal name="tag_removed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </signal>
+      <method name="add" symbol="gtk_text_tag_table_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="foreach" symbol="gtk_text_tag_table_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="func" type="GtkTextTagTableForeach"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gtk_text_tag_table_get_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_tag_table_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="lookup" symbol="gtk_text_tag_table_lookup">
+        <return-type type="GtkTextTag*"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_text_tag_table_new"/>
+      <method name="remove" symbol="gtk_text_tag_table_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="table" type="GtkTextTagTable*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTextView" parent="GtkContainer" type-name="GtkTextView">
+      <field name="layout" type="struct-_GtkTextLayout*"/>
+      <field name="buffer" type="GtkTextBuffer*"/>
+      <field name="selection_drag_handler" type="guint"/>
+      <field name="scroll_timeout" type="guint"/>
+      <field name="pixels_above_lines" type="gint"/>
+      <field name="pixels_below_lines" type="gint"/>
+      <field name="pixels_inside_wrap" type="gint"/>
+      <field name="wrap_mode" type="GtkWrapMode"/>
+      <field name="justify" type="GtkJustification"/>
+      <field name="left_margin" type="gint"/>
+      <field name="right_margin" type="gint"/>
+      <field name="indent" type="gint"/>
+      <field name="tabs" type="PangoTabArray*"/>
+      <field name="editable" type="guint"/>
+      <field name="overwrite_mode" type="guint"/>
+      <field name="cursor_visible" type="guint"/>
+      <field name="need_im_reset" type="guint"/>
+      <field name="accepts_tab" type="guint"/>
+      <field name="width_changed" type="guint"/>
+      <field name="onscreen_validated" type="guint"/>
+      <field name="mouse_cursor_obscured" type="guint"/>
+      <field name="text_window" type="GtkTextWindow*"/>
+      <field name="left_window" type="GtkTextWindow*"/>
+      <field name="right_window" type="GtkTextWindow*"/>
+      <field name="top_window" type="GtkTextWindow*"/>
+      <field name="bottom_window" type="GtkTextWindow*"/>
+      <field name="hadjustment" type="GtkAdjustment*"/>
+      <field name="vadjustment" type="GtkAdjustment*"/>
+      <field name="xoffset" type="gint"/>
+      <field name="yoffset" type="gint"/>
+      <field name="width" type="gint"/>
+      <field name="height" type="gint"/>
+      <field name="virtual_cursor_x" type="gint"/>
+      <field name="virtual_cursor_y" type="gint"/>
+      <field name="first_para_mark" type="GtkTextMark*"/>
+      <field name="first_para_pixels" type="gint"/>
+      <field name="dnd_mark" type="GtkTextMark*"/>
+      <field name="blink_timeout" type="guint"/>
+      <field name="first_validate_idle" type="guint"/>
+      <field name="incremental_validate_idle" type="guint"/>
+      <field name="im_context" type="GtkIMContext*"/>
+      <field name="popup_menu" type="GtkWidget*"/>
+      <field name="drag_start_x" type="gint"/>
+      <field name="drag_start_y" type="gint"/>
+      <field name="children" type="GSList*"/>
+      <field name="pending_scroll" type="GtkTextPendingScroll*"/>
+      <field name="pending_place_cursor_button" type="gint"/>
+      <property name="pixels-above-lines" readable="1" type="gint" writable="1"/>
+      <property name="pixels-below-lines" readable="1" type="gint" writable="1"/>
+      <property name="pixels-inside-wrap" readable="1" type="gint" writable="1"/>
+      <property name="editable" readable="1" type="gboolean" writable="1"/>
+      <property name="wrap-mode" readable="1" type="GtkWrapMode" writable="1"/>
+      <property name="justification" readable="1" type="GtkJustification" writable="1"/>
+      <property name="left-margin" readable="1" type="gint" writable="1"/>
+      <property name="right-margin" readable="1" type="gint" writable="1"/>
+      <property name="indent" readable="1" type="gint" writable="1"/>
+      <property name="tabs" readable="1" type="PangoTabArray" writable="1"/>
+      <property name="cursor-visible" readable="1" type="gboolean" writable="1"/>
+      <property name="buffer" readable="1" type="GtkTextBuffer" writable="1"/>
+      <property name="overwrite" readable="1" type="gboolean" writable="1"/>
+      <property name="accepts-tab" readable="1" type="gboolean" writable="1"/>
+      <signal name="move_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="step" type="GtkMovementStep"/>
+          <parameter name="count" type="gint"/>
+          <parameter name="extend_selection" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="page_horizontally" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="count" type="gint"/>
+          <parameter name="extend_selection" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="set_anchor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </signal>
+      <signal name="insert_at_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="str" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <signal name="delete_from_cursor" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="type" type="GtkDeleteType"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="backspace" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </signal>
+      <signal name="cut_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </signal>
+      <signal name="copy_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </signal>
+      <signal name="paste_clipboard" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_overwrite" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </signal>
+      <signal name="move_focus" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+        </parameters>
+      </signal>
+      <signal name="set_scroll_adjustments" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <signal name="populate_popup" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="menu" type="GtkMenu*"/>
+        </parameters>
+      </signal>
+      <method name="add_child_at_anchor" symbol="gtk_text_view_add_child_at_anchor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="anchor" type="GtkTextChildAnchor*"/>
+        </parameters>
+      </method>
+      <method name="add_child_in_window" symbol="gtk_text_view_add_child_in_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="which_window" type="GtkTextWindowType"/>
+          <parameter name="xpos" type="gint"/>
+          <parameter name="ypos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_display_line" symbol="gtk_text_view_backward_display_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_display_line_start" symbol="gtk_text_view_backward_display_line_start">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="buffer_to_window_coords" symbol="gtk_text_view_buffer_to_window_coords">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="win" type="GtkTextWindowType"/>
+          <parameter name="buffer_x" type="gint"/>
+          <parameter name="buffer_y" type="gint"/>
+          <parameter name="window_x" type="gint*"/>
+          <parameter name="window_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="forward_display_line" symbol="gtk_text_view_forward_display_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_display_line_end" symbol="gtk_text_view_forward_display_line_end">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_accepts_tab" symbol="gtk_text_view_get_accepts_tab">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_border_window_size" symbol="gtk_text_view_get_border_window_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="type" type="GtkTextWindowType"/>
+        </parameters>
+      </method>
+      <method name="get_buffer" symbol="gtk_text_view_get_buffer">
+        <return-type type="GtkTextBuffer*"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_cursor_visible" symbol="gtk_text_view_get_cursor_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_default_attributes" symbol="gtk_text_view_get_default_attributes">
+        <return-type type="GtkTextAttributes*"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_editable" symbol="gtk_text_view_get_editable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_indent" symbol="gtk_text_view_get_indent">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_location" symbol="gtk_text_view_get_iter_at_location">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_iter_at_position" symbol="gtk_text_view_get_iter_at_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="trailing" type="gint*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_iter_location" symbol="gtk_text_view_get_iter_location">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="location" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_justification" symbol="gtk_text_view_get_justification">
+        <return-type type="GtkJustification"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_left_margin" symbol="gtk_text_view_get_left_margin">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_line_at_y" symbol="gtk_text_view_get_line_at_y">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="target_iter" type="GtkTextIter*"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="line_top" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_line_yrange" symbol="gtk_text_view_get_line_yrange">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="y" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_overwrite" symbol="gtk_text_view_get_overwrite">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_pixels_above_lines" symbol="gtk_text_view_get_pixels_above_lines">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_pixels_below_lines" symbol="gtk_text_view_get_pixels_below_lines">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_pixels_inside_wrap" symbol="gtk_text_view_get_pixels_inside_wrap">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_right_margin" symbol="gtk_text_view_get_right_margin">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_tabs" symbol="gtk_text_view_get_tabs">
+        <return-type type="PangoTabArray*"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_view_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible_rect" symbol="gtk_text_view_get_visible_rect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="visible_rect" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_window" symbol="gtk_text_view_get_window">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="win" type="GtkTextWindowType"/>
+        </parameters>
+      </method>
+      <method name="get_window_type" symbol="gtk_text_view_get_window_type">
+        <return-type type="GtkTextWindowType"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_wrap_mode" symbol="gtk_text_view_get_wrap_mode">
+        <return-type type="GtkWrapMode"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="move_child" symbol="gtk_text_view_move_child">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="child" type="GtkWidget*"/>
+          <parameter name="xpos" type="gint"/>
+          <parameter name="ypos" type="gint"/>
+        </parameters>
+      </method>
+      <method name="move_mark_onscreen" symbol="gtk_text_view_move_mark_onscreen">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="move_visually" symbol="gtk_text_view_move_visually">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_text_view_new"/>
+      <constructor name="new_with_buffer" symbol="gtk_text_view_new_with_buffer">
+        <parameters>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </constructor>
+      <method name="place_cursor_onscreen" symbol="gtk_text_view_place_cursor_onscreen">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+        </parameters>
+      </method>
+      <method name="scroll_mark_onscreen" symbol="gtk_text_view_scroll_mark_onscreen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+        </parameters>
+      </method>
+      <method name="scroll_to_iter" symbol="gtk_text_view_scroll_to_iter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="within_margin" type="gdouble"/>
+          <parameter name="use_align" type="gboolean"/>
+          <parameter name="xalign" type="gdouble"/>
+          <parameter name="yalign" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="scroll_to_mark" symbol="gtk_text_view_scroll_to_mark">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="mark" type="GtkTextMark*"/>
+          <parameter name="within_margin" type="gdouble"/>
+          <parameter name="use_align" type="gboolean"/>
+          <parameter name="xalign" type="gdouble"/>
+          <parameter name="yalign" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_accepts_tab" symbol="gtk_text_view_set_accepts_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="accepts_tab" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_border_window_size" symbol="gtk_text_view_set_border_window_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="type" type="GtkTextWindowType"/>
+          <parameter name="size" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_buffer" symbol="gtk_text_view_set_buffer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="set_cursor_visible" symbol="gtk_text_view_set_cursor_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_editable" symbol="gtk_text_view_set_editable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_indent" symbol="gtk_text_view_set_indent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="indent" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_justification" symbol="gtk_text_view_set_justification">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="justification" type="GtkJustification"/>
+        </parameters>
+      </method>
+      <method name="set_left_margin" symbol="gtk_text_view_set_left_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="left_margin" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_overwrite" symbol="gtk_text_view_set_overwrite">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="overwrite" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_pixels_above_lines" symbol="gtk_text_view_set_pixels_above_lines">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="pixels_above_lines" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_pixels_below_lines" symbol="gtk_text_view_set_pixels_below_lines">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="pixels_below_lines" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_pixels_inside_wrap" symbol="gtk_text_view_set_pixels_inside_wrap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="pixels_inside_wrap" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_right_margin" symbol="gtk_text_view_set_right_margin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="right_margin" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_tabs" symbol="gtk_text_view_set_tabs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="tabs" type="PangoTabArray*"/>
+        </parameters>
+      </method>
+      <method name="set_wrap_mode" symbol="gtk_text_view_set_wrap_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="wrap_mode" type="GtkWrapMode"/>
+        </parameters>
+      </method>
+      <method name="starts_display_line" symbol="gtk_text_view_starts_display_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="window_to_buffer_coords" symbol="gtk_text_view_window_to_buffer_coords">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text_view" type="GtkTextView*"/>
+          <parameter name="win" type="GtkTextWindowType"/>
+          <parameter name="window_x" type="gint"/>
+          <parameter name="window_y" type="gint"/>
+          <parameter name="buffer_x" type="gint*"/>
+          <parameter name="buffer_y" type="gint*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkToggleAction" parent="GtkAction" type-name="GtkToggleAction">
+      <field name="private_data" type="GtkToggleActionPrivate*"/>
+      <property name="draw-as-radio" readable="1" type="gboolean" writable="1"/>
+      <property name="active" readable="1" type="gboolean" writable="1"/>
+      <signal name="toggled" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkToggleAction*"/>
+        </parameters>
+      </signal>
+      <method name="get_active" symbol="gtk_toggle_action_get_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="GtkToggleAction*"/>
+        </parameters>
+      </method>
+      <method name="get_draw_as_radio" symbol="gtk_toggle_action_get_draw_as_radio">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="action" type="GtkToggleAction*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_toggle_action_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_toggle_action_new">
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="label" type="const-gchar*"/>
+          <parameter name="tooltip" type="const-gchar*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_active" symbol="gtk_toggle_action_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkToggleAction*"/>
+          <parameter name="is_active" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_draw_as_radio" symbol="gtk_toggle_action_set_draw_as_radio">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkToggleAction*"/>
+          <parameter name="draw_as_radio" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="toggled" symbol="gtk_toggle_action_toggled">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="action" type="GtkToggleAction*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkToggleButton" parent="GtkButton" type-name="GtkToggleButton">
+      <field name="active" type="guint"/>
+      <field name="draw_indicator" type="guint"/>
+      <field name="inconsistent" type="guint"/>
+      <property name="active" readable="1" type="gboolean" writable="1"/>
+      <property name="inconsistent" readable="1" type="gboolean" writable="1"/>
+      <property name="draw-indicator" readable="1" type="gboolean" writable="1"/>
+      <signal name="toggled" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+        </parameters>
+      </signal>
+      <method name="get_active" symbol="gtk_toggle_button_get_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+        </parameters>
+      </method>
+      <method name="get_inconsistent" symbol="gtk_toggle_button_get_inconsistent">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+        </parameters>
+      </method>
+      <method name="get_mode" symbol="gtk_toggle_button_get_mode">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_toggle_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_toggle_button_new"/>
+      <constructor name="new_with_label" symbol="gtk_toggle_button_new_with_label">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_mnemonic" symbol="gtk_toggle_button_new_with_mnemonic">
+        <parameters>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_active" symbol="gtk_toggle_button_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+          <parameter name="is_active" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_inconsistent" symbol="gtk_toggle_button_set_inconsistent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_mode" symbol="gtk_toggle_button_set_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+          <parameter name="draw_indicator" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="toggled" symbol="gtk_toggle_button_toggled">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toggle_button" type="GtkToggleButton*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkToggleToolButton" parent="GtkToolButton" type-name="GtkToggleToolButton">
+      <field name="priv" type="GtkToggleToolButtonPrivate*"/>
+      <property name="active" readable="1" type="gboolean" writable="1"/>
+      <signal name="toggled" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToggleToolButton*"/>
+        </parameters>
+      </signal>
+      <method name="get_active" symbol="gtk_toggle_tool_button_get_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="button" type="GtkToggleToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_toggle_tool_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_toggle_tool_button_new"/>
+      <constructor name="new_from_stock" symbol="gtk_toggle_tool_button_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_active" symbol="gtk_toggle_tool_button_set_active">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToggleToolButton*"/>
+          <parameter name="is_active" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkToolbar" parent="GtkContainer" type-name="GtkToolbar">
+      <field name="num_children" readable="1" type="gint" writable="1"/>
+      <field name="children" readable="1" type="GList*" writable="1"/>
+      <field name="orientation" readable="1" type="GtkOrientation" writable="1"/>
+      <field name="style" readable="1" type="GtkToolbarStyle" writable="1"/>
+      <field name="icon_size" readable="1" type="GtkIconSize" writable="1"/>
+      <field name="tooltips" readable="1" type="GtkTooltips*" writable="1"/>
+      <field name="button_maxw" type="gint"/>
+      <field name="button_maxh" type="gint"/>
+      <field name="_gtk_reserved1" type="guint"/>
+      <field name="_gtk_reserved2" type="guint"/>
+      <field name="style_set" type="guint"/>
+      <field name="icon_size_set" type="guint"/>
+      <signal name="orientation_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </signal>
+      <signal name="style_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="style" type="GtkToolbarStyle"/>
+        </parameters>
+      </signal>
+      <signal name="popup_context_menu" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="button_number" type="gint"/>
+        </parameters>
+      </signal>
+      <property name="orientation" readable="1" type="GtkOrientation" writable="1"/>
+      <property name="toolbar-style" readable="1" type="GtkToolbarStyle" writable="1"/>
+      <property name="show-arrow" readable="1" type="gboolean" writable="1"/>
+      <property name="tooltips" readable="1" type="gboolean" writable="1"/>
+      <property name="icon-size" readable="1" type="GtkIconSize" writable="1"/>
+      <property name="icon-size-set" readable="1" type="gboolean" writable="1"/>
+      <method deprecated="1" name="append_element" symbol="gtk_toolbar_append_element">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="type" type="GtkToolbarChildType"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="icon" type="GtkWidget*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="append_item" symbol="gtk_toolbar_append_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="icon" type="GtkWidget*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="append_space" symbol="gtk_toolbar_append_space">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="append_widget" symbol="gtk_toolbar_append_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="get_drop_index" symbol="gtk_toolbar_get_drop_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_icon_size" symbol="gtk_toolbar_get_icon_size">
+        <return-type type="GtkIconSize"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_item_index" symbol="gtk_toolbar_get_item_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_n_items" symbol="gtk_toolbar_get_n_items">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_nth_item" symbol="gtk_toolbar_get_nth_item">
+        <return-type type="GtkToolItem*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="n" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_orientation" symbol="gtk_toolbar_get_orientation">
+        <return-type type="GtkOrientation"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_relief_style" symbol="gtk_toolbar_get_relief_style">
+        <return-type type="GtkReliefStyle"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_show_arrow" symbol="gtk_toolbar_get_show_arrow">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_style" symbol="gtk_toolbar_get_style">
+        <return-type type="GtkToolbarStyle"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_tooltips" symbol="gtk_toolbar_get_tooltips">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_toolbar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert" symbol="gtk_toolbar_insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="item" type="GtkToolItem*"/>
+          <parameter name="pos" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="insert_element" symbol="gtk_toolbar_insert_element">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="type" type="GtkToolbarChildType"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="icon" type="GtkWidget*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="insert_item" symbol="gtk_toolbar_insert_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="icon" type="GtkWidget*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="insert_space" symbol="gtk_toolbar_insert_space">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="insert_stock" symbol="gtk_toolbar_insert_stock">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="insert_widget" symbol="gtk_toolbar_insert_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_toolbar_new"/>
+      <method deprecated="1" name="prepend_element" symbol="gtk_toolbar_prepend_element">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="type" type="GtkToolbarChildType"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="icon" type="GtkWidget*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="prepend_item" symbol="gtk_toolbar_prepend_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+          <parameter name="icon" type="GtkWidget*"/>
+          <parameter name="callback" type="GtkSignalFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="prepend_space" symbol="gtk_toolbar_prepend_space">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="prepend_widget" symbol="gtk_toolbar_prepend_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="tooltip_text" type="const-char*"/>
+          <parameter name="tooltip_private_text" type="const-char*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove_space" symbol="gtk_toolbar_remove_space">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_drop_highlight_item" symbol="gtk_toolbar_set_drop_highlight_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_icon_size" symbol="gtk_toolbar_set_icon_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="icon_size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="set_orientation" symbol="gtk_toolbar_set_orientation">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </method>
+      <method name="set_show_arrow" symbol="gtk_toolbar_set_show_arrow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="show_arrow" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_style" symbol="gtk_toolbar_set_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="style" type="GtkToolbarStyle"/>
+        </parameters>
+      </method>
+      <method name="set_tooltips" symbol="gtk_toolbar_set_tooltips">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+          <parameter name="enable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unset_icon_size" symbol="gtk_toolbar_unset_icon_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+      <method name="unset_style" symbol="gtk_toolbar_unset_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolbar" type="GtkToolbar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTooltips" parent="GtkObject" type-name="GtkTooltips">
+      <field name="tip_window" type="GtkWidget*"/>
+      <field name="tip_label" type="GtkWidget*"/>
+      <field name="active_tips_data" type="GtkTooltipsData*"/>
+      <field name="tips_data_list" type="GList*"/>
+      <field name="delay" type="guint"/>
+      <field name="enabled" type="guint"/>
+      <field name="have_grab" type="guint"/>
+      <field name="use_sticky_delay" type="guint"/>
+      <field name="timer_tag" type="gint"/>
+      <field name="last_popdown" type="GTimeVal"/>
+      <method name="disable" symbol="gtk_tooltips_disable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+        </parameters>
+      </method>
+      <method name="enable" symbol="gtk_tooltips_enable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+        </parameters>
+      </method>
+      <method name="force_window" symbol="gtk_tooltips_force_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+        </parameters>
+      </method>
+      <method name="get_info_from_tip_window" symbol="gtk_tooltips_get_info_from_tip_window">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tip_window" type="GtkWindow*"/>
+          <parameter name="tooltips" type="GtkTooltips**"/>
+          <parameter name="current_widget" type="GtkWidget**"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tooltips_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_tooltips_new"/>
+      <method deprecated="1" name="set_delay" symbol="gtk_tooltips_set_delay">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+          <parameter name="delay" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_tip" symbol="gtk_tooltips_set_tip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="tip_text" type="const-gchar*"/>
+          <parameter name="tip_private" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkToolButton" parent="GtkToolItem" type-name="GtkToolButton">
+      <field name="priv" type="GtkToolButtonPrivate*"/>
+      <property name="label" readable="1" type="gchar*" writable="1"/>
+      <property name="use-underline" readable="1" type="gboolean" writable="1"/>
+      <property name="label-widget" readable="1" type="GtkWidget" writable="1"/>
+      <property name="stock-id" readable="1" type="gchar*" writable="1"/>
+      <property name="icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="icon-widget" readable="1" type="GtkWidget" writable="1"/>
+      <signal name="clicked" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolButton*"/>
+        </parameters>
+      </signal>
+      <method name="get_icon_name" symbol="gtk_tool_button_get_icon_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_widget" symbol="gtk_tool_button_get_icon_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_label" symbol="gtk_tool_button_get_label">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_label_widget" symbol="gtk_tool_button_get_label_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_stock_id" symbol="gtk_tool_button_get_stock_id">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tool_button_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_underline" symbol="gtk_tool_button_get_use_underline">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_tool_button_new">
+        <parameters>
+          <parameter name="icon_widget" type="GtkWidget*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_from_stock" symbol="gtk_tool_button_new_from_stock">
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="set_icon_name" symbol="gtk_tool_button_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_widget" symbol="gtk_tool_button_set_icon_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+          <parameter name="icon_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_label" symbol="gtk_tool_button_set_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+          <parameter name="label" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_label_widget" symbol="gtk_tool_button_set_label_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+          <parameter name="label_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_stock_id" symbol="gtk_tool_button_set_stock_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_use_underline" symbol="gtk_tool_button_set_use_underline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="button" type="GtkToolButton*"/>
+          <parameter name="use_underline" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkToolItem" parent="GtkBin" type-name="GtkToolItem">
+      <field name="priv" type="GtkToolItemPrivate*"/>
+      <property name="visible-horizontal" readable="1" type="gboolean" writable="1"/>
+      <property name="visible-vertical" readable="1" type="gboolean" writable="1"/>
+      <property name="is-important" readable="1" type="gboolean" writable="1"/>
+      <signal name="create_menu_proxy" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </signal>
+      <signal name="toolbar_reconfigured" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </signal>
+      <signal name="set_tooltip" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+          <parameter name="tip_text" type="const-gchar*"/>
+          <parameter name="tip_private" type="const-gchar*"/>
+        </parameters>
+      </signal>
+      <method name="get_expand" symbol="gtk_tool_item_get_expand">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_homogeneous" symbol="gtk_tool_item_get_homogeneous">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_size" symbol="gtk_tool_item_get_icon_size">
+        <return-type type="GtkIconSize"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_is_important" symbol="gtk_tool_item_get_is_important">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_orientation" symbol="gtk_tool_item_get_orientation">
+        <return-type type="GtkOrientation"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_proxy_menu_item" symbol="gtk_tool_item_get_proxy_menu_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="menu_item_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_relief_style" symbol="gtk_tool_item_get_relief_style">
+        <return-type type="GtkReliefStyle"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_toolbar_style" symbol="gtk_tool_item_get_toolbar_style">
+        <return-type type="GtkToolbarStyle"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tool_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_use_drag_window" symbol="gtk_tool_item_get_use_drag_window">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toolitem" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_visible_horizontal" symbol="gtk_tool_item_get_visible_horizontal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toolitem" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="get_visible_vertical" symbol="gtk_tool_item_get_visible_vertical">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="toolitem" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_tool_item_new"/>
+      <method name="rebuild_menu" symbol="gtk_tool_item_rebuild_menu">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="retrieve_proxy_menu_item" symbol="gtk_tool_item_retrieve_proxy_menu_item">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+        </parameters>
+      </method>
+      <method name="set_expand" symbol="gtk_tool_item_set_expand">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_homogeneous" symbol="gtk_tool_item_set_homogeneous">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="homogeneous" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_is_important" symbol="gtk_tool_item_set_is_important">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="is_important" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_proxy_menu_item" symbol="gtk_tool_item_set_proxy_menu_item">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="menu_item_id" type="const-gchar*"/>
+          <parameter name="menu_item" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_tooltip" symbol="gtk_tool_item_set_tooltip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tool_item" type="GtkToolItem*"/>
+          <parameter name="tooltips" type="GtkTooltips*"/>
+          <parameter name="tip_text" type="const-gchar*"/>
+          <parameter name="tip_private" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_use_drag_window" symbol="gtk_tool_item_set_use_drag_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolitem" type="GtkToolItem*"/>
+          <parameter name="use_drag_window" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_visible_horizontal" symbol="gtk_tool_item_set_visible_horizontal">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolitem" type="GtkToolItem*"/>
+          <parameter name="visible_horizontal" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_visible_vertical" symbol="gtk_tool_item_set_visible_vertical">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="toolitem" type="GtkToolItem*"/>
+          <parameter name="visible_vertical" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTrayIcon" parent="GtkPlug" type-name="GtkTrayIcon">
+      <field name="priv" type="GtkTrayIconPrivate*"/>
+      <property name="orientation" readable="1" type="GtkOrientation"/>
+      <method name="get_type" symbol="gtk_tray_icon_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GtkTreeModelFilter" parent="GObject" type-name="GtkTreeModelFilter">
+      <field name="priv" type="GtkTreeModelFilterPrivate*"/>
+      <property construct-only="1" name="child-model" readable="1" type="GtkTreeModel" writable="1"/>
+      <property construct-only="1" name="virtual-root" readable="1" type="GtkTreePath" writable="1"/>
+      <implements>
+        <interface name="GtkTreeModel"/>
+        <interface name="GtkTreeDragSource"/>
+      </implements>
+      <method name="clear_cache" symbol="gtk_tree_model_filter_clear_cache">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+        </parameters>
+      </method>
+      <method name="convert_child_iter_to_iter" symbol="gtk_tree_model_filter_convert_child_iter_to_iter">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="filter_iter" type="GtkTreeIter*"/>
+          <parameter name="child_iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="convert_child_path_to_path" symbol="gtk_tree_model_filter_convert_child_path_to_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="child_path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="convert_iter_to_child_iter" symbol="gtk_tree_model_filter_convert_iter_to_child_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="child_iter" type="GtkTreeIter*"/>
+          <parameter name="filter_iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="convert_path_to_child_path" symbol="gtk_tree_model_filter_convert_path_to_child_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="filter_path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_tree_model_filter_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_model_filter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_tree_model_filter_new">
+        <parameters>
+          <parameter name="child_model" type="GtkTreeModel*"/>
+          <parameter name="root" type="GtkTreePath*"/>
+        </parameters>
+      </constructor>
+      <method name="refilter" symbol="gtk_tree_model_filter_refilter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+        </parameters>
+      </method>
+      <method name="set_modify_func" symbol="gtk_tree_model_filter_set_modify_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="n_columns" type="gint"/>
+          <parameter name="types" type="GType*"/>
+          <parameter name="func" type="GtkTreeModelFilterModifyFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_visible_column" symbol="gtk_tree_model_filter_set_visible_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_visible_func" symbol="gtk_tree_model_filter_set_visible_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filter" type="GtkTreeModelFilter*"/>
+          <parameter name="func" type="GtkTreeModelFilterVisibleFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTreeModelSort" parent="GObject" type-name="GtkTreeModelSort">
+      <field name="root" type="gpointer"/>
+      <field name="stamp" type="gint"/>
+      <field name="child_flags" type="guint"/>
+      <field name="child_model" type="GtkTreeModel*"/>
+      <field name="zero_ref_count" type="gint"/>
+      <field name="sort_list" type="GList*"/>
+      <field name="sort_column_id" type="gint"/>
+      <field name="order" type="GtkSortType"/>
+      <field name="default_sort_func" type="GtkTreeIterCompareFunc"/>
+      <field name="default_sort_data" type="gpointer"/>
+      <field name="default_sort_destroy" type="GtkDestroyNotify"/>
+      <field name="changed_id" type="guint"/>
+      <field name="inserted_id" type="guint"/>
+      <field name="has_child_toggled_id" type="guint"/>
+      <field name="deleted_id" type="guint"/>
+      <field name="reordered_id" type="guint"/>
+      <property construct-only="1" name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <implements>
+        <interface name="GtkTreeModel"/>
+        <interface name="GtkTreeSortable"/>
+        <interface name="GtkTreeDragSource"/>
+      </implements>
+      <method name="clear_cache" symbol="gtk_tree_model_sort_clear_cache">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+        </parameters>
+      </method>
+      <method name="convert_child_iter_to_iter" symbol="gtk_tree_model_sort_convert_child_iter_to_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+          <parameter name="sort_iter" type="GtkTreeIter*"/>
+          <parameter name="child_iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="convert_child_path_to_path" symbol="gtk_tree_model_sort_convert_child_path_to_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+          <parameter name="child_path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="convert_iter_to_child_iter" symbol="gtk_tree_model_sort_convert_iter_to_child_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+          <parameter name="child_iter" type="GtkTreeIter*"/>
+          <parameter name="sorted_iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="convert_path_to_child_path" symbol="gtk_tree_model_sort_convert_path_to_child_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+          <parameter name="sorted_path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_tree_model_sort_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="tree_model" type="GtkTreeModelSort*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_model_sort_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="iter_is_valid" symbol="gtk_tree_model_sort_iter_is_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <constructor name="new_with_model" symbol="gtk_tree_model_sort_new_with_model">
+        <parameters>
+          <parameter name="child_model" type="GtkTreeModel*"/>
+        </parameters>
+      </constructor>
+      <method name="reset_default_sort_func" symbol="gtk_tree_model_sort_reset_default_sort_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_model_sort" type="GtkTreeModelSort*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTreeSelection" parent="GObject" type-name="GtkTreeSelection">
+      <field name="tree_view" type="GtkTreeView*"/>
+      <field name="type" type="GtkSelectionMode"/>
+      <field name="user_func" type="GtkTreeSelectionFunc"/>
+      <field name="user_data" type="gpointer"/>
+      <field name="destroy" type="GtkDestroyNotify"/>
+      <signal name="changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </signal>
+      <method name="count_selected_rows" symbol="gtk_tree_selection_count_selected_rows">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_mode" symbol="gtk_tree_selection_get_mode">
+        <return-type type="GtkSelectionMode"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_selected" symbol="gtk_tree_selection_get_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="model" type="GtkTreeModel**"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_selected_rows" symbol="gtk_tree_selection_get_selected_rows">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="model" type="GtkTreeModel**"/>
+        </parameters>
+      </method>
+      <method name="get_tree_view" symbol="gtk_tree_selection_get_tree_view">
+        <return-type type="GtkTreeView*"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_selection_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_user_data" symbol="gtk_tree_selection_get_user_data">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </method>
+      <method name="iter_is_selected" symbol="gtk_tree_selection_iter_is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="path_is_selected" symbol="gtk_tree_selection_path_is_selected">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="select_all" symbol="gtk_tree_selection_select_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </method>
+      <method name="select_iter" symbol="gtk_tree_selection_select_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="select_path" symbol="gtk_tree_selection_select_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="select_range" symbol="gtk_tree_selection_select_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="start_path" type="GtkTreePath*"/>
+          <parameter name="end_path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="selected_foreach" symbol="gtk_tree_selection_selected_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="func" type="GtkTreeSelectionForeachFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="set_mode" symbol="gtk_tree_selection_set_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="type" type="GtkSelectionMode"/>
+        </parameters>
+      </method>
+      <method name="set_select_function" symbol="gtk_tree_selection_set_select_function">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="func" type="GtkTreeSelectionFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="unselect_all" symbol="gtk_tree_selection_unselect_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+        </parameters>
+      </method>
+      <method name="unselect_iter" symbol="gtk_tree_selection_unselect_iter">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="unselect_path" symbol="gtk_tree_selection_unselect_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="unselect_range" symbol="gtk_tree_selection_unselect_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection" type="GtkTreeSelection*"/>
+          <parameter name="start_path" type="GtkTreePath*"/>
+          <parameter name="end_path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTreeStore" parent="GObject" type-name="GtkTreeStore">
+      <field name="stamp" type="gint"/>
+      <field name="root" type="gpointer"/>
+      <field name="last" type="gpointer"/>
+      <field name="n_columns" type="gint"/>
+      <field name="sort_column_id" type="gint"/>
+      <field name="sort_list" type="GList*"/>
+      <field name="order" type="GtkSortType"/>
+      <field name="column_headers" type="GType*"/>
+      <field name="default_sort_func" type="GtkTreeIterCompareFunc"/>
+      <field name="default_sort_data" type="gpointer"/>
+      <field name="default_sort_destroy" type="GtkDestroyNotify"/>
+      <field name="columns_dirty" type="guint"/>
+      <implements>
+        <interface name="GtkTreeModel"/>
+        <interface name="GtkTreeDragSource"/>
+        <interface name="GtkTreeDragDest"/>
+        <interface name="GtkTreeSortable"/>
+      </implements>
+      <method name="append" symbol="gtk_tree_store_append">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="clear" symbol="gtk_tree_store_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_store_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert" symbol="gtk_tree_store_insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_after" symbol="gtk_tree_store_insert_after">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="sibling" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="insert_before" symbol="gtk_tree_store_insert_before">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="sibling" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="insert_with_values" symbol="gtk_tree_store_insert_with_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_with_valuesv" symbol="gtk_tree_store_insert_with_valuesv">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="position" type="gint"/>
+          <parameter name="columns" type="gint*"/>
+          <parameter name="values" type="GValue*"/>
+          <parameter name="n_values" type="gint"/>
+        </parameters>
+      </method>
+      <method name="is_ancestor" symbol="gtk_tree_store_is_ancestor">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="descendant" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="iter_depth" symbol="gtk_tree_store_iter_depth">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="iter_is_valid" symbol="gtk_tree_store_iter_is_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="move_after" symbol="gtk_tree_store_move_after">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="move_before" symbol="gtk_tree_store_move_before">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="position" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_tree_store_new">
+        <parameters>
+          <parameter name="n_columns" type="gint"/>
+        </parameters>
+      </constructor>
+      <constructor name="newv" symbol="gtk_tree_store_newv">
+        <parameters>
+          <parameter name="n_columns" type="gint"/>
+          <parameter name="types" type="GType*"/>
+        </parameters>
+      </constructor>
+      <method name="prepend" symbol="gtk_tree_store_prepend">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_tree_store_remove">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="reorder" symbol="gtk_tree_store_reorder">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="parent" type="GtkTreeIter*"/>
+          <parameter name="new_order" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="set" symbol="gtk_tree_store_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="set_column_types" symbol="gtk_tree_store_set_column_types">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="n_columns" type="gint"/>
+          <parameter name="types" type="GType*"/>
+        </parameters>
+      </method>
+      <method name="set_valist" symbol="gtk_tree_store_set_valist">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="var_args" type="va_list"/>
+        </parameters>
+      </method>
+      <method name="set_value" symbol="gtk_tree_store_set_value">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="column" type="gint"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="swap" symbol="gtk_tree_store_swap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_store" type="GtkTreeStore*"/>
+          <parameter name="a" type="GtkTreeIter*"/>
+          <parameter name="b" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTreeView" parent="GtkContainer" type-name="GtkTreeView">
+      <field name="priv" type="GtkTreeViewPrivate*"/>
+      <property name="model" readable="1" type="GtkTreeModel" writable="1"/>
+      <property name="hadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="vadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="headers-visible" readable="1" type="gboolean" writable="1"/>
+      <property name="headers-clickable" readable="1" type="gboolean" writable="1"/>
+      <property name="expander-column" readable="1" type="GtkTreeViewColumn" writable="1"/>
+      <property name="reorderable" readable="1" type="gboolean" writable="1"/>
+      <property name="rules-hint" readable="1" type="gboolean" writable="1"/>
+      <property name="enable-search" readable="1" type="gboolean" writable="1"/>
+      <property name="search-column" readable="1" type="gint" writable="1"/>
+      <property name="fixed-height-mode" readable="1" type="gboolean" writable="1"/>
+      <property name="hover-selection" readable="1" type="gboolean" writable="1"/>
+      <property name="hover-expand" readable="1" type="gboolean" writable="1"/>
+      <property name="show-expanders" readable="1" type="gboolean" writable="1"/>
+      <property name="level-indentation" readable="1" type="gint" writable="1"/>
+      <property name="rubber-banding" readable="1" type="gboolean" writable="1"/>
+      <property name="enable-grid-lines" readable="1" type="GtkTreeViewGridLines" writable="1"/>
+      <property name="enable-tree-lines" readable="1" type="gboolean" writable="1"/>
+      <signal name="set_scroll_adjustments" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <signal name="row_activated" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </signal>
+      <signal name="test_expand_row" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </signal>
+      <signal name="test_collapse_row" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </signal>
+      <signal name="row_expanded" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </signal>
+      <signal name="row_collapsed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </signal>
+      <signal name="columns_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <signal name="cursor_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <signal name="move_cursor" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="step" type="GtkMovementStep"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </signal>
+      <signal name="select_all" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <signal name="unselect_all" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <signal name="select_cursor_row" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="start_editing" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="toggle_cursor_row" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <signal name="expand_collapse_cursor_row" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="logical" type="gboolean"/>
+          <parameter name="expand" type="gboolean"/>
+          <parameter name="open_all" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="select_cursor_parent" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <signal name="start_interactive_search" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </signal>
+      <method name="append_column" symbol="gtk_tree_view_append_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="collapse_all" symbol="gtk_tree_view_collapse_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="collapse_row" symbol="gtk_tree_view_collapse_row">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="columns_autosize" symbol="gtk_tree_view_columns_autosize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="create_row_drag_icon" symbol="gtk_tree_view_create_row_drag_icon">
+        <return-type type="GdkPixmap*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="enable_model_drag_dest" symbol="gtk_tree_view_enable_model_drag_dest">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="actions" type="GdkDragAction"/>
+        </parameters>
+      </method>
+      <method name="enable_model_drag_source" symbol="gtk_tree_view_enable_model_drag_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="start_button_mask" type="GdkModifierType"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="actions" type="GdkDragAction"/>
+        </parameters>
+      </method>
+      <method name="expand_all" symbol="gtk_tree_view_expand_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="expand_row" symbol="gtk_tree_view_expand_row">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="open_all" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="expand_to_path" symbol="gtk_tree_view_expand_to_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_background_area" symbol="gtk_tree_view_get_background_area">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+          <parameter name="rect" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_bin_window" symbol="gtk_tree_view_get_bin_window">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_cell_area" symbol="gtk_tree_view_get_cell_area">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+          <parameter name="rect" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_column" symbol="gtk_tree_view_get_column">
+        <return-type type="GtkTreeViewColumn*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="n" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_columns" symbol="gtk_tree_view_get_columns">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_cursor" symbol="gtk_tree_view_get_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="focus_column" type="GtkTreeViewColumn**"/>
+        </parameters>
+      </method>
+      <method name="get_dest_row_at_pos" symbol="gtk_tree_view_get_dest_row_at_pos">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="drag_x" type="gint"/>
+          <parameter name="drag_y" type="gint"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="pos" type="GtkTreeViewDropPosition*"/>
+        </parameters>
+      </method>
+      <method name="get_drag_dest_row" symbol="gtk_tree_view_get_drag_dest_row">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="pos" type="GtkTreeViewDropPosition*"/>
+        </parameters>
+      </method>
+      <method name="get_enable_search" symbol="gtk_tree_view_get_enable_search">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_enable_tree_lines" symbol="gtk_tree_view_get_enable_tree_lines">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_expander_column" symbol="gtk_tree_view_get_expander_column">
+        <return-type type="GtkTreeViewColumn*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_fixed_height_mode" symbol="gtk_tree_view_get_fixed_height_mode">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_grid_lines" symbol="gtk_tree_view_get_grid_lines">
+        <return-type type="GtkTreeViewGridLines"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_hadjustment" symbol="gtk_tree_view_get_hadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_headers_clickable" symbol="gtk_tree_view_get_headers_clickable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_headers_visible" symbol="gtk_tree_view_get_headers_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_hover_expand" symbol="gtk_tree_view_get_hover_expand">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_hover_selection" symbol="gtk_tree_view_get_hover_selection">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_tree_view_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_path_at_pos" symbol="gtk_tree_view_get_path_at_pos">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="path" type="GtkTreePath**"/>
+          <parameter name="column" type="GtkTreeViewColumn**"/>
+          <parameter name="cell_x" type="gint*"/>
+          <parameter name="cell_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_reorderable" symbol="gtk_tree_view_get_reorderable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_row_separator_func" symbol="gtk_tree_view_get_row_separator_func">
+        <return-type type="GtkTreeViewRowSeparatorFunc"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_rubber_banding" symbol="gtk_tree_view_get_rubber_banding">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_rules_hint" symbol="gtk_tree_view_get_rules_hint">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_search_column" symbol="gtk_tree_view_get_search_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_search_entry" symbol="gtk_tree_view_get_search_entry">
+        <return-type type="GtkEntry*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_search_equal_func" symbol="gtk_tree_view_get_search_equal_func">
+        <return-type type="GtkTreeViewSearchEqualFunc"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_search_position_func" symbol="gtk_tree_view_get_search_position_func">
+        <return-type type="GtkTreeViewSearchPositionFunc"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_selection" symbol="gtk_tree_view_get_selection">
+        <return-type type="GtkTreeSelection*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_view_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_vadjustment" symbol="gtk_tree_view_get_vadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="get_visible_range" symbol="gtk_tree_view_get_visible_range">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="start_path" type="GtkTreePath**"/>
+          <parameter name="end_path" type="GtkTreePath**"/>
+        </parameters>
+      </method>
+      <method name="get_visible_rect" symbol="gtk_tree_view_get_visible_rect">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="visible_rect" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="insert_column" symbol="gtk_tree_view_insert_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+          <parameter name="position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insert_column_with_attributes" symbol="gtk_tree_view_insert_column_with_attributes">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="position" type="gint"/>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="insert_column_with_data_func" symbol="gtk_tree_view_insert_column_with_data_func">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="position" type="gint"/>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="func" type="GtkTreeCellDataFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="dnotify" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="map_expanded_rows" symbol="gtk_tree_view_map_expanded_rows">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="func" type="GtkTreeViewMappingFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="mode_get_type" symbol="gtk_tree_view_mode_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="move_column_after" symbol="gtk_tree_view_move_column_after">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+          <parameter name="base_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_tree_view_new"/>
+      <constructor name="new_with_model" symbol="gtk_tree_view_new_with_model">
+        <parameters>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </constructor>
+      <method name="remove_column" symbol="gtk_tree_view_remove_column">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="row_activated" symbol="gtk_tree_view_row_activated">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="row_expanded" symbol="gtk_tree_view_row_expanded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="scroll_to_cell" symbol="gtk_tree_view_scroll_to_cell">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+          <parameter name="use_align" type="gboolean"/>
+          <parameter name="row_align" type="gfloat"/>
+          <parameter name="col_align" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="scroll_to_point" symbol="gtk_tree_view_scroll_to_point">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="tree_x" type="gint"/>
+          <parameter name="tree_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_column_drag_function" symbol="gtk_tree_view_set_column_drag_function">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="func" type="GtkTreeViewColumnDropFunc"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_cursor" symbol="gtk_tree_view_set_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="focus_column" type="GtkTreeViewColumn*"/>
+          <parameter name="start_editing" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_cursor_on_cell" symbol="gtk_tree_view_set_cursor_on_cell">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="focus_column" type="GtkTreeViewColumn*"/>
+          <parameter name="focus_cell" type="GtkCellRenderer*"/>
+          <parameter name="start_editing" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_destroy_count_func" symbol="gtk_tree_view_set_destroy_count_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="func" type="GtkTreeDestroyCountFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_drag_dest_row" symbol="gtk_tree_view_set_drag_dest_row">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="pos" type="GtkTreeViewDropPosition"/>
+        </parameters>
+      </method>
+      <method name="set_enable_search" symbol="gtk_tree_view_set_enable_search">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="enable_search" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_enable_tree_lines" symbol="gtk_tree_view_set_enable_tree_lines">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="enabled" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_expander_column" symbol="gtk_tree_view_set_expander_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="set_fixed_height_mode" symbol="gtk_tree_view_set_fixed_height_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="enable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_grid_lines" symbol="gtk_tree_view_set_grid_lines">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="grid_lines" type="GtkTreeViewGridLines"/>
+        </parameters>
+      </method>
+      <method name="set_hadjustment" symbol="gtk_tree_view_set_hadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_headers_clickable" symbol="gtk_tree_view_set_headers_clickable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_headers_visible" symbol="gtk_tree_view_set_headers_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="headers_visible" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_hover_expand" symbol="gtk_tree_view_set_hover_expand">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_hover_selection" symbol="gtk_tree_view_set_hover_selection">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="hover" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_model" symbol="gtk_tree_view_set_model">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+        </parameters>
+      </method>
+      <method name="set_reorderable" symbol="gtk_tree_view_set_reorderable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="reorderable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_row_separator_func" symbol="gtk_tree_view_set_row_separator_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="func" type="GtkTreeViewRowSeparatorFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_rubber_banding" symbol="gtk_tree_view_set_rubber_banding">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="enable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_rules_hint" symbol="gtk_tree_view_set_rules_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_search_column" symbol="gtk_tree_view_set_search_column">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_search_entry" symbol="gtk_tree_view_set_search_entry">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="entry" type="GtkEntry*"/>
+        </parameters>
+      </method>
+      <method name="set_search_equal_func" symbol="gtk_tree_view_set_search_equal_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="search_equal_func" type="GtkTreeViewSearchEqualFunc"/>
+          <parameter name="search_user_data" type="gpointer"/>
+          <parameter name="search_destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_search_position_func" symbol="gtk_tree_view_set_search_position_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="func" type="GtkTreeViewSearchPositionFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_vadjustment" symbol="gtk_tree_view_set_vadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="tree_to_widget_coords" symbol="gtk_tree_view_tree_to_widget_coords">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="tx" type="gint"/>
+          <parameter name="ty" type="gint"/>
+          <parameter name="wx" type="gint*"/>
+          <parameter name="wy" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="unset_rows_drag_dest" symbol="gtk_tree_view_unset_rows_drag_dest">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="unset_rows_drag_source" symbol="gtk_tree_view_unset_rows_drag_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+        </parameters>
+      </method>
+      <method name="widget_to_tree_coords" symbol="gtk_tree_view_widget_to_tree_coords">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_view" type="GtkTreeView*"/>
+          <parameter name="wx" type="gint"/>
+          <parameter name="wy" type="gint"/>
+          <parameter name="tx" type="gint*"/>
+          <parameter name="ty" type="gint*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkTreeViewColumn" parent="GtkObject" type-name="GtkTreeViewColumn">
+      <field name="tree_view" type="GtkWidget*"/>
+      <field name="button" type="GtkWidget*"/>
+      <field name="child" type="GtkWidget*"/>
+      <field name="arrow" type="GtkWidget*"/>
+      <field name="alignment" type="GtkWidget*"/>
+      <field name="window" type="GdkWindow*"/>
+      <field name="editable_widget" type="GtkCellEditable*"/>
+      <field name="xalign" type="gfloat"/>
+      <field name="property_changed_signal" type="guint"/>
+      <field name="spacing" type="gint"/>
+      <field name="column_type" type="GtkTreeViewColumnSizing"/>
+      <field name="requested_width" type="gint"/>
+      <field name="button_request" type="gint"/>
+      <field name="resized_width" type="gint"/>
+      <field name="width" type="gint"/>
+      <field name="fixed_width" type="gint"/>
+      <field name="min_width" type="gint"/>
+      <field name="max_width" type="gint"/>
+      <field name="drag_x" type="gint"/>
+      <field name="drag_y" type="gint"/>
+      <field name="title" type="gchar*"/>
+      <field name="cell_list" type="GList*"/>
+      <field name="sort_clicked_signal" type="guint"/>
+      <field name="sort_column_changed_signal" type="guint"/>
+      <field name="sort_column_id" type="gint"/>
+      <field name="sort_order" type="GtkSortType"/>
+      <field name="visible" type="guint"/>
+      <field name="resizable" type="guint"/>
+      <field name="clickable" type="guint"/>
+      <field name="dirty" type="guint"/>
+      <field name="show_sort_indicator" type="guint"/>
+      <field name="maybe_reordered" type="guint"/>
+      <field name="reorderable" type="guint"/>
+      <field name="use_resized_width" type="guint"/>
+      <field name="expand" type="guint"/>
+      <signal name="clicked" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </signal>
+      <property name="visible" readable="1" type="gboolean" writable="1"/>
+      <property name="resizable" readable="1" type="gboolean" writable="1"/>
+      <property name="width" readable="1" type="gint"/>
+      <property name="spacing" readable="1" type="gint" writable="1"/>
+      <property name="sizing" readable="1" type="GtkTreeViewColumnSizing" writable="1"/>
+      <property name="fixed-width" readable="1" type="gint" writable="1"/>
+      <property name="min-width" readable="1" type="gint" writable="1"/>
+      <property name="max-width" readable="1" type="gint" writable="1"/>
+      <property name="title" readable="1" type="gchar*" writable="1"/>
+      <property name="expand" readable="1" type="gboolean" writable="1"/>
+      <property name="clickable" readable="1" type="gboolean" writable="1"/>
+      <property name="widget" readable="1" type="GtkWidget" writable="1"/>
+      <property name="alignment" readable="1" type="gfloat" writable="1"/>
+      <property name="reorderable" readable="1" type="gboolean" writable="1"/>
+      <property name="sort-indicator" readable="1" type="gboolean" writable="1"/>
+      <property name="sort-order" readable="1" type="GtkSortType" writable="1"/>
+      <implements>
+        <interface name="GtkCellLayout"/>
+      </implements>
+      <method name="add_attribute" symbol="gtk_tree_view_column_add_attribute">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell_renderer" type="GtkCellRenderer*"/>
+          <parameter name="attribute" type="const-gchar*"/>
+          <parameter name="column" type="gint"/>
+        </parameters>
+      </method>
+      <method name="cell_get_position" symbol="gtk_tree_view_column_cell_get_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell_renderer" type="GtkCellRenderer*"/>
+          <parameter name="start_pos" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="cell_get_size" symbol="gtk_tree_view_column_cell_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell_area" type="GdkRectangle*"/>
+          <parameter name="x_offset" type="gint*"/>
+          <parameter name="y_offset" type="gint*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="cell_is_visible" symbol="gtk_tree_view_column_cell_is_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="cell_set_cell_data" symbol="gtk_tree_view_column_cell_set_cell_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="is_expander" type="gboolean"/>
+          <parameter name="is_expanded" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="clear" symbol="gtk_tree_view_column_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="clear_attributes" symbol="gtk_tree_view_column_clear_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell_renderer" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="clicked" symbol="gtk_tree_view_column_clicked">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="focus_cell" symbol="gtk_tree_view_column_focus_cell">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="get_alignment" symbol="gtk_tree_view_column_get_alignment">
+        <return-type type="gfloat"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_cell_renderers" symbol="gtk_tree_view_column_get_cell_renderers">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_clickable" symbol="gtk_tree_view_column_get_clickable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_expand" symbol="gtk_tree_view_column_get_expand">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_fixed_width" symbol="gtk_tree_view_column_get_fixed_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_max_width" symbol="gtk_tree_view_column_get_max_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_min_width" symbol="gtk_tree_view_column_get_min_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_reorderable" symbol="gtk_tree_view_column_get_reorderable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_resizable" symbol="gtk_tree_view_column_get_resizable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_sizing" symbol="gtk_tree_view_column_get_sizing">
+        <return-type type="GtkTreeViewColumnSizing"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_sort_column_id" symbol="gtk_tree_view_column_get_sort_column_id">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_sort_indicator" symbol="gtk_tree_view_column_get_sort_indicator">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_sort_order" symbol="gtk_tree_view_column_get_sort_order">
+        <return-type type="GtkSortType"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_spacing" symbol="gtk_tree_view_column_get_spacing">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_tree_view_column_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_view_column_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible" symbol="gtk_tree_view_column_get_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_widget" symbol="gtk_tree_view_column_get_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="get_width" symbol="gtk_tree_view_column_get_width">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_tree_view_column_new"/>
+      <constructor name="new_with_attributes" symbol="gtk_tree_view_column_new_with_attributes">
+        <parameters>
+          <parameter name="title" type="const-gchar*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+        </parameters>
+      </constructor>
+      <method name="pack_end" symbol="gtk_tree_view_column_pack_end">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="pack_start" symbol="gtk_tree_view_column_pack_start">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell" type="GtkCellRenderer*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="queue_resize" symbol="gtk_tree_view_column_queue_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+        </parameters>
+      </method>
+      <method name="set_alignment" symbol="gtk_tree_view_column_set_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="xalign" type="gfloat"/>
+        </parameters>
+      </method>
+      <method name="set_attributes" symbol="gtk_tree_view_column_set_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell_renderer" type="GtkCellRenderer*"/>
+        </parameters>
+      </method>
+      <method name="set_cell_data_func" symbol="gtk_tree_view_column_set_cell_data_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="cell_renderer" type="GtkCellRenderer*"/>
+          <parameter name="func" type="GtkTreeCellDataFunc"/>
+          <parameter name="func_data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="set_clickable" symbol="gtk_tree_view_column_set_clickable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="clickable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_expand" symbol="gtk_tree_view_column_set_expand">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="expand" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_fixed_width" symbol="gtk_tree_view_column_set_fixed_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="fixed_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_max_width" symbol="gtk_tree_view_column_set_max_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="max_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_min_width" symbol="gtk_tree_view_column_set_min_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="min_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_reorderable" symbol="gtk_tree_view_column_set_reorderable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="reorderable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_resizable" symbol="gtk_tree_view_column_set_resizable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="resizable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_sizing" symbol="gtk_tree_view_column_set_sizing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="type" type="GtkTreeViewColumnSizing"/>
+        </parameters>
+      </method>
+      <method name="set_sort_column_id" symbol="gtk_tree_view_column_set_sort_column_id">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="sort_column_id" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_sort_indicator" symbol="gtk_tree_view_column_set_sort_indicator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_sort_order" symbol="gtk_tree_view_column_set_sort_order">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="order" type="GtkSortType"/>
+        </parameters>
+      </method>
+      <method name="set_spacing" symbol="gtk_tree_view_column_set_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_tree_view_column_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_visible" symbol="gtk_tree_view_column_set_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="visible" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_widget" symbol="gtk_tree_view_column_set_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tree_column" type="GtkTreeViewColumn*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkUIManager" parent="GObject" type-name="GtkUIManager">
+      <field name="private_data" type="GtkUIManagerPrivate*"/>
+      <property name="add-tearoffs" readable="1" type="gboolean" writable="1"/>
+      <property name="ui" readable="1" type="gchar*"/>
+      <signal name="add_widget" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="merge" type="GtkUIManager*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="actions_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="merge" type="GtkUIManager*"/>
+        </parameters>
+      </signal>
+      <signal name="connect_proxy" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="merge" type="GtkUIManager*"/>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="disconnect_proxy" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="merge" type="GtkUIManager*"/>
+          <parameter name="action" type="GtkAction*"/>
+          <parameter name="proxy" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="pre_activate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="merge" type="GtkUIManager*"/>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </signal>
+      <signal name="post_activate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="merge" type="GtkUIManager*"/>
+          <parameter name="action" type="GtkAction*"/>
+        </parameters>
+      </signal>
+      <vfunc name="get_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="manager" type="GtkUIManager*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_action">
+        <return-type type="GtkAction*"/>
+        <parameters>
+          <parameter name="manager" type="GtkUIManager*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </vfunc>
+      <method name="add_ui" symbol="gtk_ui_manager_add_ui">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="merge_id" type="guint"/>
+          <parameter name="path" type="const-gchar*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="action" type="const-gchar*"/>
+          <parameter name="type" type="GtkUIManagerItemType"/>
+          <parameter name="top" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="add_ui_from_file" symbol="gtk_ui_manager_add_ui_from_file">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="filename" type="const-gchar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="add_ui_from_string" symbol="gtk_ui_manager_add_ui_from_string">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="buffer" type="const-gchar*"/>
+          <parameter name="length" type="gssize"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="ensure_update" symbol="gtk_ui_manager_ensure_update">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+        </parameters>
+      </method>
+      <method name="get_accel_group" symbol="gtk_ui_manager_get_accel_group">
+        <return-type type="GtkAccelGroup*"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+        </parameters>
+      </method>
+      <method name="get_action" symbol="gtk_ui_manager_get_action">
+        <return-type type="GtkAction*"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_action_groups" symbol="gtk_ui_manager_get_action_groups">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+        </parameters>
+      </method>
+      <method name="get_add_tearoffs" symbol="gtk_ui_manager_get_add_tearoffs">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+        </parameters>
+      </method>
+      <method name="get_toplevels" symbol="gtk_ui_manager_get_toplevels">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="types" type="GtkUIManagerItemType"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_ui_manager_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_ui" symbol="gtk_ui_manager_get_ui">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+        </parameters>
+      </method>
+      <method name="get_widget" symbol="gtk_ui_manager_get_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="insert_action_group" symbol="gtk_ui_manager_insert_action_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+          <parameter name="pos" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_ui_manager_new"/>
+      <constructor name="new_merge_id" symbol="gtk_ui_manager_new_merge_id">
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+        </parameters>
+      </constructor>
+      <method name="remove_action_group" symbol="gtk_ui_manager_remove_action_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="action_group" type="GtkActionGroup*"/>
+        </parameters>
+      </method>
+      <method name="remove_ui" symbol="gtk_ui_manager_remove_ui">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="merge_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="set_add_tearoffs" symbol="gtk_ui_manager_set_add_tearoffs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="self" type="GtkUIManager*"/>
+          <parameter name="add_tearoffs" type="gboolean"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkVBox" parent="GtkBox" type-name="GtkVBox">
+      <method name="get_type" symbol="gtk_vbox_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vbox_new">
+        <parameters>
+          <parameter name="homogeneous" type="gboolean"/>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkVButtonBox" parent="GtkButtonBox" type-name="GtkVButtonBox">
+      <method deprecated="1" name="get_layout_default" symbol="gtk_vbutton_box_get_layout_default">
+        <return-type type="GtkButtonBoxStyle"/>
+      </method>
+      <method deprecated="1" name="get_spacing_default" symbol="gtk_vbutton_box_get_spacing_default">
+        <return-type type="gint"/>
+      </method>
+      <method name="get_type" symbol="gtk_vbutton_box_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vbutton_box_new"/>
+      <method deprecated="1" name="set_layout_default" symbol="gtk_vbutton_box_set_layout_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkButtonBoxStyle"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_spacing_default" symbol="gtk_vbutton_box_set_spacing_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="spacing" type="gint"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkViewport" parent="GtkBin" type-name="GtkViewport">
+      <field name="shadow_type" type="GtkShadowType"/>
+      <field name="view_window" type="GdkWindow*"/>
+      <field name="bin_window" type="GdkWindow*"/>
+      <field name="hadjustment" type="GtkAdjustment*"/>
+      <field name="vadjustment" type="GtkAdjustment*"/>
+      <property construct="1" name="hadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property construct="1" name="vadjustment" readable="1" type="GtkAdjustment" writable="1"/>
+      <property name="shadow-type" readable="1" type="GtkShadowType" writable="1"/>
+      <signal name="set_scroll_adjustments" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </signal>
+      <method name="get_hadjustment" symbol="gtk_viewport_get_hadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+        </parameters>
+      </method>
+      <method name="get_shadow_type" symbol="gtk_viewport_get_shadow_type">
+        <return-type type="GtkShadowType"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_viewport_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_vadjustment" symbol="gtk_viewport_get_vadjustment">
+        <return-type type="GtkAdjustment*"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_viewport_new">
+        <parameters>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+      <method name="set_hadjustment" symbol="gtk_viewport_set_hadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_shadow_type" symbol="gtk_viewport_set_shadow_type">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+          <parameter name="type" type="GtkShadowType"/>
+        </parameters>
+      </method>
+      <method name="set_vadjustment" symbol="gtk_viewport_set_vadjustment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="viewport" type="GtkViewport*"/>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkVPaned" parent="GtkPaned" type-name="GtkVPaned">
+      <method name="get_type" symbol="gtk_vpaned_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vpaned_new"/>
+    </object>
+    <object get-type="" name="GtkVRuler" parent="GtkRuler" type-name="GtkVRuler">
+      <method name="get_type" symbol="gtk_vruler_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vruler_new"/>
+    </object>
+    <object get-type="" name="GtkVScale" parent="GtkScale" type-name="GtkVScale">
+      <method name="get_type" symbol="gtk_vscale_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vscale_new">
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+      <constructor name="new_with_range" symbol="gtk_vscale_new_with_range">
+        <parameters>
+          <parameter name="min" type="gdouble"/>
+          <parameter name="max" type="gdouble"/>
+          <parameter name="step" type="gdouble"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkVScrollbar" parent="GtkScrollbar" type-name="GtkVScrollbar">
+      <method name="get_type" symbol="gtk_vscrollbar_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vscrollbar_new">
+        <parameters>
+          <parameter name="adjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </constructor>
+    </object>
+    <object get-type="" name="GtkVSeparator" parent="GtkSeparator" type-name="GtkVSeparator">
+      <method name="get_type" symbol="gtk_vseparator_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_vseparator_new"/>
+    </object>
+    <object get-type="" name="GtkWidget" parent="GtkObject" type-name="GtkWidget">
+      <field name="private_flags" type="guint16"/>
+      <field name="state" type="guint8"/>
+      <field name="saved_state" type="guint8"/>
+      <field name="name" type="gchar*"/>
+      <field name="style" readable="1" type="GtkStyle*" writable="1"/>
+      <field name="requisition" readable="1" type="GtkRequisition" writable="1"/>
+      <field name="allocation" readable="1" type="GtkAllocation" writable="1"/>
+      <field name="window" readable="1" type="GdkWindow*" writable="1"/>
+      <field name="parent" readable="1" type="GtkWidget*" writable="1"/>
+      <property name="name" readable="1" type="gchar*" writable="1"/>
+      <property name="parent" readable="1" type="GtkContainer" writable="1"/>
+      <property name="width-request" readable="1" type="gint" writable="1"/>
+      <property name="height-request" readable="1" type="gint" writable="1"/>
+      <property name="visible" readable="1" type="gboolean" writable="1"/>
+      <property name="sensitive" readable="1" type="gboolean" writable="1"/>
+      <property name="app-paintable" readable="1" type="gboolean" writable="1"/>
+      <property name="can-focus" readable="1" type="gboolean" writable="1"/>
+      <property name="has-focus" readable="1" type="gboolean" writable="1"/>
+      <property name="is-focus" readable="1" type="gboolean" writable="1"/>
+      <property name="can-default" readable="1" type="gboolean" writable="1"/>
+      <property name="has-default" readable="1" type="gboolean" writable="1"/>
+      <property name="receives-default" readable="1" type="gboolean" writable="1"/>
+      <property name="composite-child" readable="1" type="gboolean"/>
+      <property name="style" readable="1" type="GtkStyle" writable="1"/>
+      <property name="events" readable="1" type="GdkEventMask" writable="1"/>
+      <property name="extension-events" readable="1" type="GdkExtensionMode" writable="1"/>
+      <property name="no-show-all" readable="1" type="gboolean" writable="1"/>
+      <signal name="show" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="hide" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="map" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="unmap" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="realize" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="unrealize" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="size_request" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="requisition" type="GtkRequisition*"/>
+        </parameters>
+      </signal>
+      <signal name="size_allocate" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="allocation" type="GtkAllocation*"/>
+        </parameters>
+      </signal>
+      <signal name="state_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="previous_state" type="GtkStateType"/>
+        </parameters>
+      </signal>
+      <signal name="parent_set" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="previous_parent" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="hierarchy_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="previous_toplevel" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="style_set" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="previous_style" type="GtkStyle*"/>
+        </parameters>
+      </signal>
+      <signal name="direction_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="previous_direction" type="GtkTextDirection"/>
+        </parameters>
+      </signal>
+      <signal name="grab_notify" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="was_grabbed" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="child_notify" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="pspec" type="GParamSpec*"/>
+        </parameters>
+      </signal>
+      <signal name="mnemonic_activate" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="group_cycling" type="gboolean"/>
+        </parameters>
+      </signal>
+      <signal name="grab_focus" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="focus" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+        </parameters>
+      </signal>
+      <signal name="event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </signal>
+      <signal name="event_after" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkWidget*"/>
+          <parameter name="p0" type="GdkEvent"/>
+        </parameters>
+      </signal>
+      <signal name="button_press_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventButton*"/>
+        </parameters>
+      </signal>
+      <signal name="button_release_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventButton*"/>
+        </parameters>
+      </signal>
+      <signal name="scroll_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventScroll*"/>
+        </parameters>
+      </signal>
+      <signal name="motion_notify_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventMotion*"/>
+        </parameters>
+      </signal>
+      <signal name="composited_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="delete_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventAny*"/>
+        </parameters>
+      </signal>
+      <signal name="destroy_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventAny*"/>
+        </parameters>
+      </signal>
+      <signal name="expose_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventExpose*"/>
+        </parameters>
+      </signal>
+      <signal name="key_press_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </signal>
+      <signal name="key_release_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </signal>
+      <signal name="enter_notify_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventCrossing*"/>
+        </parameters>
+      </signal>
+      <signal name="leave_notify_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventCrossing*"/>
+        </parameters>
+      </signal>
+      <signal name="configure_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventConfigure*"/>
+        </parameters>
+      </signal>
+      <signal name="focus_in_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventFocus*"/>
+        </parameters>
+      </signal>
+      <signal name="focus_out_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventFocus*"/>
+        </parameters>
+      </signal>
+      <signal name="map_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventAny*"/>
+        </parameters>
+      </signal>
+      <signal name="unmap_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventAny*"/>
+        </parameters>
+      </signal>
+      <signal name="property_notify_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventProperty*"/>
+        </parameters>
+      </signal>
+      <signal name="selection_clear_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventSelection*"/>
+        </parameters>
+      </signal>
+      <signal name="selection_request_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventSelection*"/>
+        </parameters>
+      </signal>
+      <signal name="selection_notify_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventSelection*"/>
+        </parameters>
+      </signal>
+      <signal name="selection_received" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="selection_get" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="info" type="guint"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="proximity_in_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventProximity*"/>
+        </parameters>
+      </signal>
+      <signal name="proximity_out_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventProximity*"/>
+        </parameters>
+      </signal>
+      <signal name="drag_leave" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="drag_begin" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </signal>
+      <signal name="drag_end" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </signal>
+      <signal name="drag_data_delete" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </signal>
+      <signal name="drag_motion" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="drag_drop" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="drag_data_get" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="info" type="guint"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="drag_data_received" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="info" type="guint"/>
+          <parameter name="time_" type="guint"/>
+        </parameters>
+      </signal>
+      <signal name="visibility_notify_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventVisibility*"/>
+        </parameters>
+      </signal>
+      <signal name="client_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventClient*"/>
+        </parameters>
+      </signal>
+      <signal name="no_expose_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventAny*"/>
+        </parameters>
+      </signal>
+      <signal name="window_state_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventWindowState*"/>
+        </parameters>
+      </signal>
+      <signal name="grab_broken_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventGrabBroken*"/>
+        </parameters>
+      </signal>
+      <signal name="popup_menu" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="show_help" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="help_type" type="GtkWidgetHelpType"/>
+        </parameters>
+      </signal>
+      <signal name="accel_closures_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="inst" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="screen_changed" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="previous_screen" type="GdkScreen*"/>
+        </parameters>
+      </signal>
+      <signal name="can_activate_accel" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="signal_id" type="guint"/>
+        </parameters>
+      </signal>
+      <vfunc name="dispatch_child_properties_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="n_pspecs" type="guint"/>
+          <parameter name="pspecs" type="GParamSpec**"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="show_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="hide_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="get_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </vfunc>
+      <implements>
+        <interface name="AtkImplementor"/>
+      </implements>
+      <method name="activate" symbol="gtk_widget_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="add_accelerator" symbol="gtk_widget_add_accelerator">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="accel_signal" type="const-gchar*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+          <parameter name="accel_flags" type="GtkAccelFlags"/>
+        </parameters>
+      </method>
+      <method name="add_events" symbol="gtk_widget_add_events">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="events" type="gint"/>
+        </parameters>
+      </method>
+      <method name="add_mnemonic_label" symbol="gtk_widget_add_mnemonic_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="can_activate_accel" symbol="gtk_widget_can_activate_accel">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="signal_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="child_focus" symbol="gtk_widget_child_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+        </parameters>
+      </method>
+      <method name="child_notify" symbol="gtk_widget_child_notify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="child_property" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="class_find_style_property" symbol="gtk_widget_class_find_style_property">
+        <return-type type="GParamSpec*"/>
+        <parameters>
+          <parameter name="klass" type="GtkWidgetClass*"/>
+          <parameter name="property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="class_install_style_property" symbol="gtk_widget_class_install_style_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="klass" type="GtkWidgetClass*"/>
+          <parameter name="pspec" type="GParamSpec*"/>
+        </parameters>
+      </method>
+      <method name="class_install_style_property_parser" symbol="gtk_widget_class_install_style_property_parser">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="klass" type="GtkWidgetClass*"/>
+          <parameter name="pspec" type="GParamSpec*"/>
+          <parameter name="parser" type="GtkRcPropertyParser"/>
+        </parameters>
+      </method>
+      <method name="class_list_style_properties" symbol="gtk_widget_class_list_style_properties">
+        <return-type type="GParamSpec**"/>
+        <parameters>
+          <parameter name="klass" type="GtkWidgetClass*"/>
+          <parameter name="n_properties" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="class_path" symbol="gtk_widget_class_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="path_length" type="guint*"/>
+          <parameter name="path" type="gchar**"/>
+          <parameter name="path_reversed" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="create_pango_context" symbol="gtk_widget_create_pango_context">
+        <return-type type="PangoContext*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="create_pango_layout" symbol="gtk_widget_create_pango_layout">
+        <return-type type="PangoLayout*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="text" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="gtk_widget_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="destroyed" symbol="gtk_widget_destroyed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="widget_pointer" type="GtkWidget**"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="draw" symbol="gtk_widget_draw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="ensure_style" symbol="gtk_widget_ensure_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="event" symbol="gtk_widget_event">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="freeze_child_notify" symbol="gtk_widget_freeze_child_notify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_accessible" symbol="gtk_widget_get_accessible">
+        <return-type type="AtkObject*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_action" symbol="gtk_widget_get_action">
+        <return-type type="GtkAction*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_ancestor" symbol="gtk_widget_get_ancestor">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="widget_type" type="GType"/>
+        </parameters>
+      </method>
+      <method name="get_child_requisition" symbol="gtk_widget_get_child_requisition">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="requisition" type="GtkRequisition*"/>
+        </parameters>
+      </method>
+      <method name="get_child_visible" symbol="gtk_widget_get_child_visible">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_clipboard" symbol="gtk_widget_get_clipboard">
+        <return-type type="GtkClipboard*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="get_colormap" symbol="gtk_widget_get_colormap">
+        <return-type type="GdkColormap*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_composite_name" symbol="gtk_widget_get_composite_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_default_colormap" symbol="gtk_widget_get_default_colormap">
+        <return-type type="GdkColormap*"/>
+      </method>
+      <method name="get_default_direction" symbol="gtk_widget_get_default_direction">
+        <return-type type="GtkTextDirection"/>
+      </method>
+      <method name="get_default_style" symbol="gtk_widget_get_default_style">
+        <return-type type="GtkStyle*"/>
+      </method>
+      <method name="get_default_visual" symbol="gtk_widget_get_default_visual">
+        <return-type type="GdkVisual*"/>
+      </method>
+      <method name="get_direction" symbol="gtk_widget_get_direction">
+        <return-type type="GtkTextDirection"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_display" symbol="gtk_widget_get_display">
+        <return-type type="GdkDisplay*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_events" symbol="gtk_widget_get_events">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_extension_events" symbol="gtk_widget_get_extension_events">
+        <return-type type="GdkExtensionMode"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_modifier_style" symbol="gtk_widget_get_modifier_style">
+        <return-type type="GtkRcStyle*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_widget_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_no_show_all" symbol="gtk_widget_get_no_show_all">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_pango_context" symbol="gtk_widget_get_pango_context">
+        <return-type type="PangoContext*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_parent" symbol="gtk_widget_get_parent">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_parent_window" symbol="gtk_widget_get_parent_window">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_pointer" symbol="gtk_widget_get_pointer">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint*"/>
+          <parameter name="y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_root_window" symbol="gtk_widget_get_root_window">
+        <return-type type="GdkWindow*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gtk_widget_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_settings" symbol="gtk_widget_get_settings">
+        <return-type type="GtkSettings*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_size_request" symbol="gtk_widget_get_size_request">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_style" symbol="gtk_widget_get_style">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_toplevel" symbol="gtk_widget_get_toplevel">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_widget_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visual" symbol="gtk_widget_get_visual">
+        <return-type type="GdkVisual*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="grab_default" symbol="gtk_widget_grab_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="grab_focus" symbol="gtk_widget_grab_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="has_screen" symbol="gtk_widget_has_screen">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="hide" symbol="gtk_widget_hide">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="hide_all" symbol="gtk_widget_hide_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="hide_on_delete" symbol="gtk_widget_hide_on_delete">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="input_shape_combine_mask" symbol="gtk_widget_input_shape_combine_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="shape_mask" type="GdkBitmap*"/>
+          <parameter name="offset_x" type="gint"/>
+          <parameter name="offset_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="intersect" symbol="gtk_widget_intersect">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="intersection" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="is_ancestor" symbol="gtk_widget_is_ancestor">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="ancestor" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="is_composited" symbol="gtk_widget_is_composited">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="is_focus" symbol="gtk_widget_is_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="list_accel_closures" symbol="gtk_widget_list_accel_closures">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="list_mnemonic_labels" symbol="gtk_widget_list_mnemonic_labels">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="map" symbol="gtk_widget_map">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="mnemonic_activate" symbol="gtk_widget_mnemonic_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="group_cycling" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="modify_base" symbol="gtk_widget_modify_base">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="modify_bg" symbol="gtk_widget_modify_bg">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="modify_fg" symbol="gtk_widget_modify_fg">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="modify_font" symbol="gtk_widget_modify_font">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="font_desc" type="PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="modify_style" symbol="gtk_widget_modify_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="style" type="GtkRcStyle*"/>
+        </parameters>
+      </method>
+      <method name="modify_text" symbol="gtk_widget_modify_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="color" type="const-GdkColor*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_widget_new">
+        <parameters>
+          <parameter name="type" type="GType"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </constructor>
+      <method name="path" symbol="gtk_widget_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="path_length" type="guint*"/>
+          <parameter name="path" type="gchar**"/>
+          <parameter name="path_reversed" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="pop_colormap" symbol="gtk_widget_pop_colormap">
+        <return-type type="void"/>
+      </method>
+      <method name="pop_composite_child" symbol="gtk_widget_pop_composite_child">
+        <return-type type="void"/>
+      </method>
+      <method name="push_colormap" symbol="gtk_widget_push_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cmap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="push_composite_child" symbol="gtk_widget_push_composite_child">
+        <return-type type="void"/>
+      </method>
+      <method deprecated="1" name="queue_clear" symbol="gtk_widget_queue_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="queue_clear_area" symbol="gtk_widget_queue_clear_area">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="queue_draw" symbol="gtk_widget_queue_draw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="queue_draw_area" symbol="gtk_widget_queue_draw_area">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="queue_resize" symbol="gtk_widget_queue_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="queue_resize_no_redraw" symbol="gtk_widget_queue_resize_no_redraw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="realize" symbol="gtk_widget_realize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="gtk_widget_ref">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="region_intersect" symbol="gtk_widget_region_intersect">
+        <return-type type="GdkRegion*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="region" type="GdkRegion*"/>
+        </parameters>
+      </method>
+      <method name="remove_accelerator" symbol="gtk_widget_remove_accelerator">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="remove_mnemonic_label" symbol="gtk_widget_remove_mnemonic_label">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="label" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="render_icon" symbol="gtk_widget_render_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="size" type="GtkIconSize"/>
+          <parameter name="detail" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="reparent" symbol="gtk_widget_reparent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="new_parent" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="reset_rc_styles" symbol="gtk_widget_reset_rc_styles">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="reset_shapes" symbol="gtk_widget_reset_shapes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="send_expose" symbol="gtk_widget_send_expose">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set" symbol="gtk_widget_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_accel_path" symbol="gtk_widget_set_accel_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="accel_path" type="const-gchar*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <method name="set_app_paintable" symbol="gtk_widget_set_app_paintable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="app_paintable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_child_visible" symbol="gtk_widget_set_child_visible">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="is_visible" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_colormap" symbol="gtk_widget_set_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="set_composite_name" symbol="gtk_widget_set_composite_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_default_colormap" symbol="gtk_widget_set_default_colormap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+        </parameters>
+      </method>
+      <method name="set_default_direction" symbol="gtk_widget_set_default_direction">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="dir" type="GtkTextDirection"/>
+        </parameters>
+      </method>
+      <method name="set_direction" symbol="gtk_widget_set_direction">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="dir" type="GtkTextDirection"/>
+        </parameters>
+      </method>
+      <method name="set_double_buffered" symbol="gtk_widget_set_double_buffered">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="double_buffered" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_events" symbol="gtk_widget_set_events">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="events" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_extension_events" symbol="gtk_widget_set_extension_events">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="mode" type="GdkExtensionMode"/>
+        </parameters>
+      </method>
+      <method name="set_name" symbol="gtk_widget_set_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_no_show_all" symbol="gtk_widget_set_no_show_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="no_show_all" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_parent" symbol="gtk_widget_set_parent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="parent" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_parent_window" symbol="gtk_widget_set_parent_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="parent_window" type="GdkWindow*"/>
+        </parameters>
+      </method>
+      <method name="set_redraw_on_allocate" symbol="gtk_widget_set_redraw_on_allocate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="redraw_on_allocate" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_scroll_adjustments" symbol="gtk_widget_set_scroll_adjustments">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="hadjustment" type="GtkAdjustment*"/>
+          <parameter name="vadjustment" type="GtkAdjustment*"/>
+        </parameters>
+      </method>
+      <method name="set_sensitive" symbol="gtk_widget_set_sensitive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="sensitive" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_size_request" symbol="gtk_widget_set_size_request">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_state" symbol="gtk_widget_set_state">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="state" type="GtkStateType"/>
+        </parameters>
+      </method>
+      <method name="set_style" symbol="gtk_widget_set_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="style" type="GtkStyle*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_uposition" symbol="gtk_widget_set_uposition">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_usize" symbol="gtk_widget_set_usize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="shape_combine_mask" symbol="gtk_widget_shape_combine_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="shape_mask" type="GdkBitmap*"/>
+          <parameter name="offset_x" type="gint"/>
+          <parameter name="offset_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="show" symbol="gtk_widget_show">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="show_all" symbol="gtk_widget_show_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="show_now" symbol="gtk_widget_show_now">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="size_allocate" symbol="gtk_widget_size_allocate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="allocation" type="GtkAllocation*"/>
+        </parameters>
+      </method>
+      <method name="size_request" symbol="gtk_widget_size_request">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="requisition" type="GtkRequisition*"/>
+        </parameters>
+      </method>
+      <method name="style_get" symbol="gtk_widget_style_get">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="style_get_property" symbol="gtk_widget_style_get_property">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="property_name" type="const-gchar*"/>
+          <parameter name="value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="style_get_valist" symbol="gtk_widget_style_get_valist">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+          <parameter name="var_args" type="va_list"/>
+        </parameters>
+      </method>
+      <method name="thaw_child_notify" symbol="gtk_widget_thaw_child_notify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="translate_coordinates" symbol="gtk_widget_translate_coordinates">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="src_widget" type="GtkWidget*"/>
+          <parameter name="dest_widget" type="GtkWidget*"/>
+          <parameter name="src_x" type="gint"/>
+          <parameter name="src_y" type="gint"/>
+          <parameter name="dest_x" type="gint*"/>
+          <parameter name="dest_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="unmap" symbol="gtk_widget_unmap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="unparent" symbol="gtk_widget_unparent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="unrealize" symbol="gtk_widget_unrealize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gtk_widget_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkWin32EmbedWidget" parent="GtkWindow" type-name="GtkWin32EmbedWidget">
+      <field name="parent_window" type="GdkWindow*"/>
+      <field name="old_window_procedure" type="gpointer"/>
+      <method name="get_type" symbol="gtk_win32_embed_widget_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="GtkWindow" parent="GtkBin" type-name="GtkWindow">
+      <field name="title" type="gchar*"/>
+      <field name="wmclass_name" type="gchar*"/>
+      <field name="wmclass_class" type="gchar*"/>
+      <field name="wm_role" type="gchar*"/>
+      <field name="focus_widget" type="GtkWidget*"/>
+      <field name="default_widget" type="GtkWidget*"/>
+      <field name="transient_parent" type="GtkWindow*"/>
+      <field name="geometry_info" type="GtkWindowGeometryInfo*"/>
+      <field name="frame" type="GdkWindow*"/>
+      <field name="group" type="GtkWindowGroup*"/>
+      <field name="configure_request_count" type="guint16"/>
+      <field name="allow_shrink" type="guint"/>
+      <field name="allow_grow" type="guint"/>
+      <field name="configure_notify_received" type="guint"/>
+      <field name="need_default_position" type="guint"/>
+      <field name="need_default_size" type="guint"/>
+      <field name="position" type="guint"/>
+      <field name="type" type="guint"/>
+      <field name="has_user_ref_count" type="guint"/>
+      <field name="has_focus" type="guint"/>
+      <field name="modal" type="guint"/>
+      <field name="destroy_with_parent" type="guint"/>
+      <field name="has_frame" type="guint"/>
+      <field name="iconify_initially" type="guint"/>
+      <field name="stick_initially" type="guint"/>
+      <field name="maximize_initially" type="guint"/>
+      <field name="decorated" type="guint"/>
+      <field name="type_hint" type="guint"/>
+      <field name="gravity" type="guint"/>
+      <field name="is_active" type="guint"/>
+      <field name="has_toplevel_focus" type="guint"/>
+      <field name="frame_left" type="guint"/>
+      <field name="frame_top" type="guint"/>
+      <field name="frame_right" type="guint"/>
+      <field name="frame_bottom" type="guint"/>
+      <field name="keys_changed_handler" type="guint"/>
+      <field name="mnemonic_modifier" type="GdkModifierType"/>
+      <field name="screen" type="GdkScreen*"/>
+      <property construct-only="1" name="type" readable="1" type="GtkWindowType" writable="1"/>
+      <property name="title" readable="1" type="gchar*" writable="1"/>
+      <property name="role" readable="1" type="gchar*" writable="1"/>
+      <property name="allow-shrink" readable="1" type="gboolean" writable="1"/>
+      <property name="allow-grow" readable="1" type="gboolean" writable="1"/>
+      <property name="resizable" readable="1" type="gboolean" writable="1"/>
+      <property name="modal" readable="1" type="gboolean" writable="1"/>
+      <property name="window-position" readable="1" type="GtkWindowPosition" writable="1"/>
+      <property name="default-width" readable="1" type="gint" writable="1"/>
+      <property name="default-height" readable="1" type="gint" writable="1"/>
+      <property name="destroy-with-parent" readable="1" type="gboolean" writable="1"/>
+      <property name="icon" readable="1" type="GdkPixbuf" writable="1"/>
+      <property name="icon-name" readable="1" type="gchar*" writable="1"/>
+      <property name="screen" readable="1" type="GdkScreen" writable="1"/>
+      <property name="is-active" readable="1" type="gboolean"/>
+      <property name="has-toplevel-focus" readable="1" type="gboolean"/>
+      <property name="type-hint" readable="1" type="GdkWindowTypeHint" writable="1"/>
+      <property name="skip-taskbar-hint" readable="1" type="gboolean" writable="1"/>
+      <property name="skip-pager-hint" readable="1" type="gboolean" writable="1"/>
+      <property name="urgency-hint" readable="1" type="gboolean" writable="1"/>
+      <property name="accept-focus" readable="1" type="gboolean" writable="1"/>
+      <property name="focus-on-map" readable="1" type="gboolean" writable="1"/>
+      <property name="decorated" readable="1" type="gboolean" writable="1"/>
+      <property name="deletable" readable="1" type="gboolean" writable="1"/>
+      <property name="gravity" readable="1" type="GdkGravity" writable="1"/>
+      <property construct="1" name="transient-for" readable="1" type="GtkWindow" writable="1"/>
+      <signal name="set_focus" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="focus" type="GtkWidget*"/>
+        </parameters>
+      </signal>
+      <signal name="frame_event" when="LAST">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </signal>
+      <signal name="activate_focus" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </signal>
+      <signal name="activate_default" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </signal>
+      <signal name="move_focus" when="LAST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="direction" type="GtkDirectionType"/>
+        </parameters>
+      </signal>
+      <signal name="keys_changed" when="FIRST">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </signal>
+      <method name="activate_default" symbol="gtk_window_activate_default">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="activate_focus" symbol="gtk_window_activate_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="activate_key" symbol="gtk_window_activate_key">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </method>
+      <method name="add_accel_group" symbol="gtk_window_add_accel_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <method name="add_embedded_xid" symbol="gtk_window_add_embedded_xid">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="xid" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_mnemonic" symbol="gtk_window_add_mnemonic">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="target" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="begin_move_drag" symbol="gtk_window_begin_move_drag">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="button" type="gint"/>
+          <parameter name="root_x" type="gint"/>
+          <parameter name="root_y" type="gint"/>
+          <parameter name="timestamp" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="begin_resize_drag" symbol="gtk_window_begin_resize_drag">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="edge" type="GdkWindowEdge"/>
+          <parameter name="button" type="gint"/>
+          <parameter name="root_x" type="gint"/>
+          <parameter name="root_y" type="gint"/>
+          <parameter name="timestamp" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="deiconify" symbol="gtk_window_deiconify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="fullscreen" symbol="gtk_window_fullscreen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_accept_focus" symbol="gtk_window_get_accept_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_decorated" symbol="gtk_window_get_decorated">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_default_icon_list" symbol="gtk_window_get_default_icon_list">
+        <return-type type="GList*"/>
+      </method>
+      <method name="get_default_size" symbol="gtk_window_get_default_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_deletable" symbol="gtk_window_get_deletable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_destroy_with_parent" symbol="gtk_window_get_destroy_with_parent">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_focus" symbol="gtk_window_get_focus">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_focus_on_map" symbol="gtk_window_get_focus_on_map">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_frame_dimensions" symbol="gtk_window_get_frame_dimensions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="left" type="gint*"/>
+          <parameter name="top" type="gint*"/>
+          <parameter name="right" type="gint*"/>
+          <parameter name="bottom" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_gravity" symbol="gtk_window_get_gravity">
+        <return-type type="GdkGravity"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_group" symbol="gtk_window_get_group">
+        <return-type type="GtkWindowGroup*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_has_frame" symbol="gtk_window_get_has_frame">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_icon" symbol="gtk_window_get_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_list" symbol="gtk_window_get_icon_list">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_name" symbol="gtk_window_get_icon_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_mnemonic_modifier" symbol="gtk_window_get_mnemonic_modifier">
+        <return-type type="GdkModifierType"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_modal" symbol="gtk_window_get_modal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_position" symbol="gtk_window_get_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="root_x" type="gint*"/>
+          <parameter name="root_y" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_resizable" symbol="gtk_window_get_resizable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_role" symbol="gtk_window_get_role">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_screen" symbol="gtk_window_get_screen">
+        <return-type type="GdkScreen*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gtk_window_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_skip_pager_hint" symbol="gtk_window_get_skip_pager_hint">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_skip_taskbar_hint" symbol="gtk_window_get_skip_taskbar_hint">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_title" symbol="gtk_window_get_title">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_transient_for" symbol="gtk_window_get_transient_for">
+        <return-type type="GtkWindow*"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_window_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_type_hint" symbol="gtk_window_get_type_hint">
+        <return-type type="GdkWindowTypeHint"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_urgency_hint" symbol="gtk_window_get_urgency_hint">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="has_toplevel_focus" symbol="gtk_window_has_toplevel_focus">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="iconify" symbol="gtk_window_iconify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="is_active" symbol="gtk_window_is_active">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="list_toplevels" symbol="gtk_window_list_toplevels">
+        <return-type type="GList*"/>
+      </method>
+      <method name="maximize" symbol="gtk_window_maximize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="mnemonic_activate" symbol="gtk_window_mnemonic_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifier" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="move" symbol="gtk_window_move">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="gtk_window_new">
+        <parameters>
+          <parameter name="type" type="GtkWindowType"/>
+        </parameters>
+      </constructor>
+      <method name="parse_geometry" symbol="gtk_window_parse_geometry">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="geometry" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="present" symbol="gtk_window_present">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="present_with_time" symbol="gtk_window_present_with_time">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="timestamp" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="propagate_key_event" symbol="gtk_window_propagate_key_event">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </method>
+      <method name="remove_accel_group" symbol="gtk_window_remove_accel_group">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="accel_group" type="GtkAccelGroup*"/>
+        </parameters>
+      </method>
+      <method name="remove_embedded_xid" symbol="gtk_window_remove_embedded_xid">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="xid" type="guint"/>
+        </parameters>
+      </method>
+      <method name="remove_mnemonic" symbol="gtk_window_remove_mnemonic">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="target" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="reshow_with_initial_size" symbol="gtk_window_reshow_with_initial_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="resize" symbol="gtk_window_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_accept_focus" symbol="gtk_window_set_accept_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_auto_startup_notification" symbol="gtk_window_set_auto_startup_notification">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_decorated" symbol="gtk_window_set_decorated">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_default" symbol="gtk_window_set_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="default_widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_default_icon" symbol="gtk_window_set_default_icon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_default_icon_from_file" symbol="gtk_window_set_default_icon_from_file">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="filename" type="const-gchar*"/>
+          <parameter name="err" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_default_icon_list" symbol="gtk_window_set_default_icon_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GList*"/>
+        </parameters>
+      </method>
+      <method name="set_default_icon_name" symbol="gtk_window_set_default_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_default_size" symbol="gtk_window_set_default_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_deletable" symbol="gtk_window_set_deletable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_destroy_with_parent" symbol="gtk_window_set_destroy_with_parent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_focus" symbol="gtk_window_set_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="focus" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="set_focus_on_map" symbol="gtk_window_set_focus_on_map">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_frame_dimensions" symbol="gtk_window_set_frame_dimensions">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="left" type="gint"/>
+          <parameter name="top" type="gint"/>
+          <parameter name="right" type="gint"/>
+          <parameter name="bottom" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_geometry_hints" symbol="gtk_window_set_geometry_hints">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="geometry_widget" type="GtkWidget*"/>
+          <parameter name="geometry" type="GdkGeometry*"/>
+          <parameter name="geom_mask" type="GdkWindowHints"/>
+        </parameters>
+      </method>
+      <method name="set_gravity" symbol="gtk_window_set_gravity">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="gravity" type="GdkGravity"/>
+        </parameters>
+      </method>
+      <method name="set_has_frame" symbol="gtk_window_set_has_frame">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_icon" symbol="gtk_window_set_icon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="icon" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_from_file" symbol="gtk_window_set_icon_from_file">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="filename" type="const-gchar*"/>
+          <parameter name="err" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_icon_list" symbol="gtk_window_set_icon_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="list" type="GList*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_name" symbol="gtk_window_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_keep_above" symbol="gtk_window_set_keep_above">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_keep_below" symbol="gtk_window_set_keep_below">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_mnemonic_modifier" symbol="gtk_window_set_mnemonic_modifier">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="modifier" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="set_modal" symbol="gtk_window_set_modal">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="modal" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_policy" symbol="gtk_window_set_policy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="allow_shrink" type="gint"/>
+          <parameter name="allow_grow" type="gint"/>
+          <parameter name="auto_shrink" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_position" symbol="gtk_window_set_position">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="position" type="GtkWindowPosition"/>
+        </parameters>
+      </method>
+      <method name="set_resizable" symbol="gtk_window_set_resizable">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="resizable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_role" symbol="gtk_window_set_role">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="role" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_screen" symbol="gtk_window_set_screen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="set_skip_pager_hint" symbol="gtk_window_set_skip_pager_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_skip_taskbar_hint" symbol="gtk_window_set_skip_taskbar_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_title" symbol="gtk_window_set_title">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="title" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_transient_for" symbol="gtk_window_set_transient_for">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="parent" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="set_type_hint" symbol="gtk_window_set_type_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="hint" type="GdkWindowTypeHint"/>
+        </parameters>
+      </method>
+      <method name="set_urgency_hint" symbol="gtk_window_set_urgency_hint">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_wmclass" symbol="gtk_window_set_wmclass">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+          <parameter name="wmclass_name" type="const-gchar*"/>
+          <parameter name="wmclass_class" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="stick" symbol="gtk_window_stick">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="unfullscreen" symbol="gtk_window_unfullscreen">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="unmaximize" symbol="gtk_window_unmaximize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="unstick" symbol="gtk_window_unstick">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="GtkWindowGroup" parent="GObject" type-name="GtkWindowGroup">
+      <field name="grabs" type="GSList*"/>
+      <method name="add_window" symbol="gtk_window_group_add_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window_group" type="GtkWindowGroup*"/>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_window_group_get_type">
+        <return-type type="GType"/>
+      </method>
+      <constructor name="new" symbol="gtk_window_group_new"/>
+      <method name="remove_window" symbol="gtk_window_group_remove_window">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="window_group" type="GtkWindowGroup*"/>
+          <parameter name="window" type="GtkWindow*"/>
+        </parameters>
+      </method>
+    </object>
+    <struct get-type="" name="GtkAccelGroupEntry" type-name="GtkAccelGroupEntry">
+      <field name="key" readable="1" type="GtkAccelKey" writable="1"/>
+      <field name="closure" readable="1" type="GClosure*" writable="1"/>
+      <field name="accel_path_quark" readable="1" type="GQuark" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkAccelKey" type-name="GtkAccelKey">
+      <field name="accel_key" readable="1" type="guint" writable="1"/>
+      <field name="accel_mods" readable="1" type="GdkModifierType" writable="1"/>
+      <field name="accel_flags" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkActionEntry" type-name="GtkActionEntry">
+      <field name="name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="stock_id" readable="1" type="const-gchar*" writable="1"/>
+      <field name="label" readable="1" type="const-gchar*" writable="1"/>
+      <field name="accelerator" readable="1" type="const-gchar*" writable="1"/>
+      <field name="tooltip" readable="1" type="const-gchar*" writable="1"/>
+      <field name="callback" readable="1" type="GCallback" writable="1"/>
+    </struct>
+    <struct deprecated="1" get-type="" name="GtkArg" type-name="GtkArg">
+      <field name="type" readable="1" type="GtkType" writable="1"/>
+      <field name="name" readable="1" type="gchar*" writable="1"/>
+      <field name="char_data" readable="1" type="gchar" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkBindingArg" type-name="GtkBindingArg">
+      <field name="arg_type" readable="1" type="GType" writable="1"/>
+      <field name="long_data" readable="1" type="glong" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkBindingEntry" type-name="GtkBindingEntry">
+      <field name="keyval" readable="1" type="guint" writable="1"/>
+      <field name="modifiers" readable="1" type="GdkModifierType" writable="1"/>
+      <field name="binding_set" readable="1" type="GtkBindingSet*" writable="1"/>
+      <field name="destroyed" readable="1" type="guint" writable="1"/>
+      <field name="in_emission" readable="1" type="guint" writable="1"/>
+      <field name="set_next" readable="1" type="GtkBindingEntry*" writable="1"/>
+      <field name="hash_next" readable="1" type="GtkBindingEntry*" writable="1"/>
+      <field name="signals" readable="1" type="GtkBindingSignal*" writable="1"/>
+      <method name="add_signal" symbol="gtk_binding_entry_add_signal">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="binding_set" type="GtkBindingSet*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+          <parameter name="signal_name" type="const-gchar*"/>
+          <parameter name="n_args" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_signall" symbol="gtk_binding_entry_add_signall">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="binding_set" type="GtkBindingSet*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+          <parameter name="signal_name" type="const-gchar*"/>
+          <parameter name="binding_args" type="GSList*"/>
+        </parameters>
+      </method>
+      <method name="clear" symbol="gtk_binding_entry_clear">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="binding_set" type="GtkBindingSet*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_binding_entry_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="binding_set" type="GtkBindingSet*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GtkBindingSet" opaque="true" type-name="GtkBindingSet">
+      <field access="public" name="set_name" readable="1" type="gchar*" writable="1" writeable="true"/>
+      <field access="public" name="priority" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="widget_path_pspecs" readable="1" type="GSList*" writable="1" writeable="true"/>
+      <field access="public" name="widget_class_pspecs" readable="1" type="GSList*" writable="1" writeable="true"/>
+      <field access="public" name="class_branch_pspecs" readable="1" type="GSList*" writable="1" writeable="true"/>
+      <field access="public" name="entries" readable="1" type="GtkBindingEntry*" writable="1" writeable="true"/>
+      <field access="public" name="current" readable="1" type="GtkBindingEntry*" writable="1" writeable="true"/>
+      <field access="public" name="parsed" readable="1" type="guint" writable="1" writeable="true"/>
+      <method name="activate" symbol="gtk_binding_set_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="binding_set" type="GtkBindingSet*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method name="add_path" symbol="gtk_binding_set_add_path">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="binding_set" type="GtkBindingSet*"/>
+          <parameter name="path_type" type="GtkPathType"/>
+          <parameter name="path_pattern" type="const-gchar*"/>
+          <parameter name="priority" type="GtkPathPriorityType"/>
+        </parameters>
+      </method>
+      <method name="by_class" symbol="gtk_binding_set_by_class">
+        <return-type type="GtkBindingSet*"/>
+        <parameters>
+          <parameter name="object_class" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="find" symbol="gtk_binding_set_find">
+        <return-type type="GtkBindingSet*"/>
+        <parameters>
+          <parameter name="set_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gtk_binding_set_new">
+        <return-type type="GtkBindingSet*"/>
+        <parameters>
+          <parameter name="set_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GtkBindingSignal" type-name="GtkBindingSignal">
+      <field name="next" readable="1" type="GtkBindingSignal*" writable="1"/>
+      <field name="signal_name" readable="1" type="gchar*" writable="1"/>
+      <field name="n_args" readable="1" type="guint" writable="1"/>
+      <field name="args" readable="1" type="GtkBindingArg*" writable="1"/>
+    </struct>
+    <boxed get-type="" name="GtkBorder" type-name="GtkBorder">
+      <field name="left" readable="1" type="gint" writable="1"/>
+      <field name="right" readable="1" type="gint" writable="1"/>
+      <field name="top" readable="1" type="gint" writable="1"/>
+      <field name="bottom" readable="1" type="gint" writable="1"/>
+      <method name="copy" symbol="gtk_border_copy">
+        <return-type type="GtkBorder*"/>
+        <parameters>
+          <parameter name="border_" type="const-GtkBorder*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_border_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="border_" type="GtkBorder*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_border_get_type">
+        <return-type type="GType"/>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkBoxChild" type-name="GtkBoxChild">
+      <field name="widget" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="padding" readable="1" type="guint16" writable="1"/>
+      <field name="expand" readable="1" type="guint" writable="1"/>
+      <field name="fill" readable="1" type="guint" writable="1"/>
+      <field name="pack" readable="1" type="guint" writable="1"/>
+      <field name="is_secondary" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkFileFilterInfo" type-name="GtkFileFilterInfo">
+      <field name="contains" readable="1" type="GtkFileFilterFlags" writable="1"/>
+      <field name="filename" readable="1" type="const-gchar*" writable="1"/>
+      <field name="uri" readable="1" type="const-gchar*" writable="1"/>
+      <field name="display_name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="mime_type" readable="1" type="const-gchar*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkFixedChild" type-name="GtkFixedChild">
+      <field name="widget" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkIMContextInfo" type-name="GtkIMContextInfo">
+      <field name="context_id" readable="1" type="const-gchar*" writable="1"/>
+      <field name="context_name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="domain" readable="1" type="const-gchar*" writable="1"/>
+      <field name="domain_dirname" readable="1" type="const-gchar*" writable="1"/>
+      <field name="default_locales" readable="1" type="const-gchar*" writable="1"/>
+    </struct>
+    <boxed get-type="" name="GtkIconInfo" opaque="true" type-name="GtkIconInfo">
+      <method name="copy" symbol="gtk_icon_info_copy">
+        <return-type type="GtkIconInfo*"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_icon_info_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_attach_points" symbol="gtk_icon_info_get_attach_points">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+          <parameter name="points" type="GdkPoint**"/>
+          <parameter name="n_points" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_base_size" symbol="gtk_icon_info_get_base_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_builtin_pixbuf" symbol="gtk_icon_info_get_builtin_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_display_name" symbol="gtk_icon_info_get_display_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_embedded_rect" symbol="gtk_icon_info_get_embedded_rect">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+          <parameter name="rectangle" type="GdkRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_filename" symbol="gtk_icon_info_get_filename">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_icon_info_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="load_icon" symbol="gtk_icon_info_load_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="set_raw_coordinates" symbol="gtk_icon_info_set_raw_coordinates">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_info" type="GtkIconInfo*"/>
+          <parameter name="raw_coordinates" type="gboolean"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="GtkIconSet" opaque="true" type-name="GtkIconSet">
+      <method name="add_source" symbol="gtk_icon_set_add_source">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="gtk_icon_set_copy">
+        <return-type type="GtkIconSet*"/>
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+        </parameters>
+      </method>
+      <method name="get_sizes" symbol="gtk_icon_set_get_sizes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+          <parameter name="sizes" type="GtkIconSize**"/>
+          <parameter name="n_sizes" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_icon_set_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="gtk_icon_set_new">
+        <return-type type="GtkIconSet*"/>
+      </method>
+      <method name="new_from_pixbuf" symbol="gtk_icon_set_new_from_pixbuf">
+        <return-type type="GtkIconSet*"/>
+        <parameters>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="gtk_icon_set_ref">
+        <return-type type="GtkIconSet*"/>
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+        </parameters>
+      </method>
+      <method name="render_icon" symbol="gtk_icon_set_render_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="direction" type="GtkTextDirection"/>
+          <parameter name="state" type="GtkStateType"/>
+          <parameter name="size" type="GtkIconSize"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gtk_icon_set_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="icon_set" type="GtkIconSet*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="GtkIconSource" opaque="true" type-name="GtkIconSource">
+      <method name="copy" symbol="gtk_icon_source_copy">
+        <return-type type="GtkIconSource*"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_icon_source_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_direction" symbol="gtk_icon_source_get_direction">
+        <return-type type="GtkTextDirection"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_direction_wildcarded" symbol="gtk_icon_source_get_direction_wildcarded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_filename" symbol="gtk_icon_source_get_filename">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_icon_name" symbol="gtk_icon_source_get_icon_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gtk_icon_source_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="gtk_icon_source_get_size">
+        <return-type type="GtkIconSize"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_size_wildcarded" symbol="gtk_icon_source_get_size_wildcarded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_state" symbol="gtk_icon_source_get_state">
+        <return-type type="GtkStateType"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_state_wildcarded" symbol="gtk_icon_source_get_state_wildcarded">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="source" type="const-GtkIconSource*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_icon_source_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="gtk_icon_source_new">
+        <return-type type="GtkIconSource*"/>
+      </method>
+      <method name="set_direction" symbol="gtk_icon_source_set_direction">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="direction" type="GtkTextDirection"/>
+        </parameters>
+      </method>
+      <method name="set_direction_wildcarded" symbol="gtk_icon_source_set_direction_wildcarded">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_filename" symbol="gtk_icon_source_set_filename">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_name" symbol="gtk_icon_source_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="set_pixbuf" symbol="gtk_icon_source_set_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_size" symbol="gtk_icon_source_set_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="set_size_wildcarded" symbol="gtk_icon_source_set_size_wildcarded">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_state" symbol="gtk_icon_source_set_state">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="state" type="GtkStateType"/>
+        </parameters>
+      </method>
+      <method name="set_state_wildcarded" symbol="gtk_icon_source_set_state_wildcarded">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="source" type="GtkIconSource*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkImageAnimationData" type-name="GtkImageAnimationData">
+      <field name="anim" readable="1" type="GdkPixbufAnimation*" writable="1"/>
+      <field name="iter" readable="1" type="GdkPixbufAnimationIter*" writable="1"/>
+      <field name="frame_timeout" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkImageIconNameData" type-name="GtkImageIconNameData">
+      <field name="icon_name" readable="1" type="gchar*" writable="1"/>
+      <field name="pixbuf" readable="1" type="GdkPixbuf*" writable="1"/>
+      <field name="theme_change_id" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkImageIconSetData" type-name="GtkImageIconSetData">
+      <field name="icon_set" readable="1" type="GtkIconSet*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkImageImageData" type-name="GtkImageImageData">
+      <field name="image" readable="1" type="GdkImage*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkImagePixbufData" type-name="GtkImagePixbufData">
+      <field name="pixbuf" readable="1" type="GdkPixbuf*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkImagePixmapData" type-name="GtkImagePixmapData">
+      <field name="pixmap" readable="1" type="GdkPixmap*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkImageStockData" type-name="GtkImageStockData">
+      <field name="stock_id" readable="1" type="gchar*" writable="1"/>
+    </struct>
+    <struct deprecated="1" get-type="" name="GtkItemFactoryEntry" type-name="GtkItemFactoryEntry">
+      <field name="path" readable="1" type="gchar*" writable="1"/>
+      <field name="accelerator" readable="1" type="gchar*" writable="1"/>
+      <field name="callback" readable="1" type="GtkItemFactoryCallback" writable="1"/>
+      <field name="callback_action" readable="1" type="guint" writable="1"/>
+      <field name="item_type" readable="1" type="gchar*" writable="1"/>
+      <field name="extra_data" readable="1" type="gconstpointer" writable="1"/>
+    </struct>
+    <struct deprecated="1" get-type="" name="GtkItemFactoryItem" type-name="GtkItemFactoryItem">
+      <field name="path" readable="1" type="gchar*" writable="1"/>
+      <field name="widgets" readable="1" type="GSList*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkKeyHash" opaque="true" type-name="GtkKeyHash"/>
+    <struct get-type="" name="GtkLabelSelectionInfo" opaque="true" type-name="GtkLabelSelectionInfo"/>
+    <struct get-type="" name="GtkMenuEntry" type-name="GtkMenuEntry">
+      <field name="path" readable="1" type="gchar*" writable="1"/>
+      <field name="accelerator" readable="1" type="gchar*" writable="1"/>
+      <field name="callback" readable="1" type="GtkMenuCallback" writable="1"/>
+      <field name="callback_data" readable="1" type="gpointer" writable="1"/>
+      <field name="widget" readable="1" type="GtkWidget*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkMnemonicHash" opaque="true" type-name="GtkMnemonicHash"/>
+    <struct get-type="" name="GtkNotebookPage" opaque="true" type-name="GtkNotebookPage">
+      <method name="num" symbol="gtk_notebook_page_num">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="notebook" type="GtkNotebook*"/>
+          <parameter name="child" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GtkPageRange" type-name="GtkPageRange">
+      <field name="start" readable="1" type="gint" writable="1"/>
+      <field name="end" readable="1" type="gint" writable="1"/>
+    </struct>
+    <boxed get-type="" name="GtkPaperSize" opaque="true" type-name="GtkPaperSize">
+      <method name="copy" symbol="gtk_paper_size_copy">
+        <return-type type="GtkPaperSize*"/>
+        <parameters>
+          <parameter name="other" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_paper_size_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="get_default" symbol="gtk_paper_size_get_default">
+        <return-type type="const-gchar*"/>
+      </method>
+      <method name="get_default_bottom_margin" symbol="gtk_paper_size_get_default_bottom_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_default_left_margin" symbol="gtk_paper_size_get_default_left_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_default_right_margin" symbol="gtk_paper_size_get_default_right_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_default_top_margin" symbol="gtk_paper_size_get_default_top_margin">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_display_name" symbol="gtk_paper_size_get_display_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="get_height" symbol="gtk_paper_size_get_height">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="get_name" symbol="gtk_paper_size_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="get_ppd_name" symbol="gtk_paper_size_get_ppd_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_paper_size_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="gtk_paper_size_get_width">
+        <return-type type="gdouble"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="is_custom" symbol="gtk_paper_size_is_custom">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="is_equal" symbol="gtk_paper_size_is_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="size1" type="GtkPaperSize*"/>
+          <parameter name="size2" type="GtkPaperSize*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gtk_paper_size_new">
+        <return-type type="GtkPaperSize*"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="new_custom" symbol="gtk_paper_size_new_custom">
+        <return-type type="GtkPaperSize*"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="display_name" type="const-gchar*"/>
+          <parameter name="width" type="gdouble"/>
+          <parameter name="height" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+      <method name="new_from_ppd" symbol="gtk_paper_size_new_from_ppd">
+        <return-type type="GtkPaperSize*"/>
+        <parameters>
+          <parameter name="ppd_name" type="const-gchar*"/>
+          <parameter name="ppd_display_name" type="const-gchar*"/>
+          <parameter name="width" type="gdouble"/>
+          <parameter name="height" type="gdouble"/>
+        </parameters>
+      </method>
+      <method name="set_size" symbol="gtk_paper_size_set_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="size" type="GtkPaperSize*"/>
+          <parameter name="width" type="gdouble"/>
+          <parameter name="height" type="gdouble"/>
+          <parameter name="unit" type="GtkUnit"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkPrintWin32Devnames" type-name="GtkPrintWin32Devnames">
+      <field name="driver" readable="1" type="char*" writable="1"/>
+      <field name="device" readable="1" type="char*" writable="1"/>
+      <field name="output" readable="1" type="char*" writable="1"/>
+      <field name="flags" readable="1" type="int" writable="1"/>
+      <method name="free" symbol="gtk_print_win32_devnames_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="devnames" type="GtkPrintWin32Devnames*"/>
+        </parameters>
+      </method>
+      <method name="from_printer_name" symbol="gtk_print_win32_devnames_from_printer_name">
+        <return-type type="HGLOBAL"/>
+        <parameters>
+          <parameter name="printer" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="from_win32" symbol="gtk_print_win32_devnames_from_win32">
+        <return-type type="GtkPrintWin32Devnames*"/>
+        <parameters>
+          <parameter name="global" type="HGLOBAL"/>
+        </parameters>
+      </method>
+      <method name="to_win32" symbol="gtk_print_win32_devnames_to_win32">
+        <return-type type="HGLOBAL"/>
+        <parameters>
+          <parameter name="devnames" type="const-GtkPrintWin32Devnames*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GtkRadioActionEntry" type-name="GtkRadioActionEntry">
+      <field name="name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="stock_id" readable="1" type="const-gchar*" writable="1"/>
+      <field name="label" readable="1" type="const-gchar*" writable="1"/>
+      <field name="accelerator" readable="1" type="const-gchar*" writable="1"/>
+      <field name="tooltip" readable="1" type="const-gchar*" writable="1"/>
+      <field name="value" readable="1" type="gint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkRangeLayout" opaque="true" type-name="GtkRangeLayout"/>
+    <struct get-type="" name="GtkRangeStepTimer" opaque="true" type-name="GtkRangeStepTimer"/>
+    <struct get-type="" name="GtkRcContext" opaque="true" type-name="GtkRcContext"/>
+    <struct get-type="" name="GtkRcProperty" type-name="GtkRcProperty">
+      <field name="type_name" readable="1" type="GQuark" writable="1"/>
+      <field name="property_name" readable="1" type="GQuark" writable="1"/>
+      <field name="origin" readable="1" type="gchar*" writable="1"/>
+      <field name="value" readable="1" type="GValue" writable="1"/>
+      <method name="parse_border" symbol="gtk_rc_property_parse_border">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pspec" type="const-GParamSpec*"/>
+          <parameter name="gstring" type="const-GString*"/>
+          <parameter name="property_value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="parse_color" symbol="gtk_rc_property_parse_color">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pspec" type="const-GParamSpec*"/>
+          <parameter name="gstring" type="const-GString*"/>
+          <parameter name="property_value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="parse_enum" symbol="gtk_rc_property_parse_enum">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pspec" type="const-GParamSpec*"/>
+          <parameter name="gstring" type="const-GString*"/>
+          <parameter name="property_value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="parse_flags" symbol="gtk_rc_property_parse_flags">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pspec" type="const-GParamSpec*"/>
+          <parameter name="gstring" type="const-GString*"/>
+          <parameter name="property_value" type="GValue*"/>
+        </parameters>
+      </method>
+      <method name="parse_requisition" symbol="gtk_rc_property_parse_requisition">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pspec" type="const-GParamSpec*"/>
+          <parameter name="gstring" type="const-GString*"/>
+          <parameter name="property_value" type="GValue*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GtkRecentData" type-name="GtkRecentData">
+      <field name="display_name" readable="1" type="gchar*" writable="1"/>
+      <field name="description" readable="1" type="gchar*" writable="1"/>
+      <field name="mime_type" readable="1" type="gchar*" writable="1"/>
+      <field name="app_name" readable="1" type="gchar*" writable="1"/>
+      <field name="app_exec" readable="1" type="gchar*" writable="1"/>
+      <field name="groups" readable="1" type="gchar**" writable="1"/>
+      <field name="is_private" readable="1" type="gboolean" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkRecentFilterInfo" type-name="GtkRecentFilterInfo">
+      <field name="contains" readable="1" type="GtkRecentFilterFlags" writable="1"/>
+      <field name="uri" readable="1" type="const-gchar*" writable="1"/>
+      <field name="display_name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="mime_type" readable="1" type="const-gchar*" writable="1"/>
+      <field name="applications" readable="1" type="const-gchar**" writable="1"/>
+      <field name="groups" readable="1" type="const-gchar**" writable="1"/>
+      <field name="age" readable="1" type="gint" writable="1"/>
+    </struct>
+    <boxed get-type="" name="GtkRecentInfo" opaque="true" type-name="GtkRecentInfo">
+      <method name="exists" symbol="gtk_recent_info_exists">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_added" symbol="gtk_recent_info_get_added">
+        <return-type type="time_t"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_age" symbol="gtk_recent_info_get_age">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_application_info" symbol="gtk_recent_info_get_application_info">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+          <parameter name="app_name" type="const-gchar*"/>
+          <parameter name="app_exec" type="gchar**"/>
+          <parameter name="count" type="guint*"/>
+          <parameter name="time_" type="time_t*"/>
+        </parameters>
+      </method>
+      <method name="get_applications" symbol="gtk_recent_info_get_applications">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+          <parameter name="length" type="gsize*"/>
+        </parameters>
+      </method>
+      <method name="get_description" symbol="gtk_recent_info_get_description">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_display_name" symbol="gtk_recent_info_get_display_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_groups" symbol="gtk_recent_info_get_groups">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+          <parameter name="length" type="gsize*"/>
+        </parameters>
+      </method>
+      <method name="get_icon" symbol="gtk_recent_info_get_icon">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+          <parameter name="size" type="gint"/>
+        </parameters>
+      </method>
+      <method name="get_mime_type" symbol="gtk_recent_info_get_mime_type">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_modified" symbol="gtk_recent_info_get_modified">
+        <return-type type="time_t"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_private_hint" symbol="gtk_recent_info_get_private_hint">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_short_name" symbol="gtk_recent_info_get_short_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_recent_info_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uri" symbol="gtk_recent_info_get_uri">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_uri_display" symbol="gtk_recent_info_get_uri_display">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="get_visited" symbol="gtk_recent_info_get_visited">
+        <return-type type="time_t"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="has_application" symbol="gtk_recent_info_has_application">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+          <parameter name="app_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="has_group" symbol="gtk_recent_info_has_group">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+          <parameter name="group_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="is_local" symbol="gtk_recent_info_is_local">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="last_application" symbol="gtk_recent_info_last_application">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="match" symbol="gtk_recent_info_match">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="info_a" type="GtkRecentInfo*"/>
+          <parameter name="info_b" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="gtk_recent_info_ref">
+        <return-type type="GtkRecentInfo*"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gtk_recent_info_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="info" type="GtkRecentInfo*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="GtkRequisition" type-name="GtkRequisition">
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+      <method name="copy" symbol="gtk_requisition_copy">
+        <return-type type="GtkRequisition*"/>
+        <parameters>
+          <parameter name="requisition" type="const-GtkRequisition*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_requisition_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="requisition" type="GtkRequisition*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_requisition_get_type">
+        <return-type type="GType"/>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkRulerMetric" type-name="GtkRulerMetric">
+      <field name="metric_name" readable="1" type="gchar*" writable="1"/>
+      <field name="abbrev" readable="1" type="gchar*" writable="1"/>
+      <field name="pixels_per_unit" readable="1" type="gdouble" writable="1"/>
+      <field name="ruler_scale" readable="1" type="gdouble" writable="1"/>
+      <field name="subdivide" readable="1" type="gint" writable="1"/>
+    </struct>
+    <boxed get-type="" name="GtkSelectionData" type-name="GtkSelectionData">
+      <field name="selection" readable="1" type="GdkAtom" writable="1"/>
+      <field name="target" readable="1" type="GdkAtom" writable="1"/>
+      <field name="type" readable="1" type="GdkAtom" writable="1"/>
+      <field name="format" readable="1" type="gint" writable="1"/>
+      <field name="data" readable="1" type="guchar*" writable="1"/>
+      <field name="length" readable="1" type="gint" writable="1"/>
+      <field name="display" readable="1" type="GdkDisplay*" writable="1"/>
+      <method name="copy" symbol="gtk_selection_data_copy">
+        <return-type type="GtkSelectionData*"/>
+        <parameters>
+          <parameter name="data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_selection_data_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gtk_selection_data_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="get_targets" symbol="gtk_selection_data_get_targets">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="targets" type="GdkAtom**"/>
+          <parameter name="n_atoms" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="gtk_selection_data_get_text">
+        <return-type type="guchar*"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_selection_data_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_uris" symbol="gtk_selection_data_get_uris">
+        <return-type type="gchar**"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="set" symbol="gtk_selection_data_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="type" type="GdkAtom"/>
+          <parameter name="format" type="gint"/>
+          <parameter name="data" type="const-guchar*"/>
+          <parameter name="length" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_pixbuf" symbol="gtk_selection_data_set_pixbuf">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="gtk_selection_data_set_text">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="str" type="const-gchar*"/>
+          <parameter name="len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_uris" symbol="gtk_selection_data_set_uris">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="uris" type="gchar**"/>
+        </parameters>
+      </method>
+      <method name="targets_include_image" symbol="gtk_selection_data_targets_include_image">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="writable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="targets_include_rich_text" symbol="gtk_selection_data_targets_include_rich_text">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="targets_include_text" symbol="gtk_selection_data_targets_include_text">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+      <method name="targets_include_uri" symbol="gtk_selection_data_targets_include_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkSettingsPropertyValue" opaque="true" type-name="GtkSettingsPropertyValue"/>
+    <struct get-type="" name="GtkSettingsValue" type-name="GtkSettingsValue">
+      <field name="origin" readable="1" type="gchar*" writable="1"/>
+      <field name="value" readable="1" type="GValue" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkStockItem" type-name="GtkStockItem">
+      <field name="stock_id" readable="1" type="gchar*" writable="1"/>
+      <field name="label" readable="1" type="gchar*" writable="1"/>
+      <field name="modifier" readable="1" type="GdkModifierType" writable="1"/>
+      <field name="keyval" readable="1" type="guint" writable="1"/>
+      <field name="translation_domain" readable="1" type="gchar*" writable="1"/>
+      <method name="copy" symbol="gtk_stock_item_copy">
+        <return-type type="GtkStockItem*"/>
+        <parameters>
+          <parameter name="item" type="const-GtkStockItem*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_stock_item_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="GtkStockItem*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="GtkTableChild" type-name="GtkTableChild">
+      <field name="widget" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="left_attach" readable="1" type="guint16" writable="1"/>
+      <field name="right_attach" readable="1" type="guint16" writable="1"/>
+      <field name="top_attach" readable="1" type="guint16" writable="1"/>
+      <field name="bottom_attach" readable="1" type="guint16" writable="1"/>
+      <field name="xpadding" readable="1" type="guint16" writable="1"/>
+      <field name="ypadding" readable="1" type="guint16" writable="1"/>
+      <field name="xexpand" readable="1" type="guint" writable="1"/>
+      <field name="yexpand" readable="1" type="guint" writable="1"/>
+      <field name="xshrink" readable="1" type="guint" writable="1"/>
+      <field name="yshrink" readable="1" type="guint" writable="1"/>
+      <field name="xfill" readable="1" type="guint" writable="1"/>
+      <field name="yfill" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkTableRowCol" type-name="GtkTableRowCol">
+      <field name="requisition" readable="1" type="guint16" writable="1"/>
+      <field name="allocation" readable="1" type="guint16" writable="1"/>
+      <field name="spacing" readable="1" type="guint16" writable="1"/>
+      <field name="need_expand" readable="1" type="guint" writable="1"/>
+      <field name="need_shrink" readable="1" type="guint" writable="1"/>
+      <field name="expand" readable="1" type="guint" writable="1"/>
+      <field name="shrink" readable="1" type="guint" writable="1"/>
+      <field name="empty" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkTargetEntry" type-name="GtkTargetEntry">
+      <field name="target" readable="1" type="gchar*" writable="1"/>
+      <field name="flags" readable="1" type="guint" writable="1"/>
+      <field name="info" readable="1" type="guint" writable="1"/>
+    </struct>
+    <boxed get-type="" name="GtkTargetList" opaque="true" type-name="GtkTargetList">
+      <field access="public" name="list" readable="1" type="GList*" writable="1" writeable="true"/>
+      <field access="public" name="ref_count" readable="1" type="guint" writable="1" writeable="true"/>
+      <method name="add" symbol="gtk_target_list_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="flags" type="guint"/>
+          <parameter name="info" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_image_targets" symbol="gtk_target_list_add_image_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="info" type="guint"/>
+          <parameter name="writable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="add_rich_text_targets" symbol="gtk_target_list_add_rich_text_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="info" type="guint"/>
+          <parameter name="deserializable" type="gboolean"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="add_table" symbol="gtk_target_list_add_table">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="ntargets" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_text_targets" symbol="gtk_target_list_add_text_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="info" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_uri_targets" symbol="gtk_target_list_add_uri_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="info" type="guint"/>
+        </parameters>
+      </method>
+      <method name="find" symbol="gtk_target_list_find">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="info" type="guint*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_target_list_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="gtk_target_list_new">
+        <return-type type="GtkTargetList*"/>
+        <parameters>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="ntargets" type="guint"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="gtk_target_list_ref">
+        <return-type type="GtkTargetList*"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_target_list_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="target" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gtk_target_list_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkTargetPair" type-name="GtkTargetPair">
+      <field name="target" readable="1" type="GdkAtom" writable="1"/>
+      <field name="flags" readable="1" type="guint" writable="1"/>
+      <field name="info" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkTextAppearance" type-name="GtkTextAppearance">
+      <field name="bg_color" readable="1" type="GdkColor" writable="1"/>
+      <field name="fg_color" readable="1" type="GdkColor" writable="1"/>
+      <field name="bg_stipple" readable="1" type="GdkBitmap*" writable="1"/>
+      <field name="fg_stipple" readable="1" type="GdkBitmap*" writable="1"/>
+      <field name="rise" readable="1" type="gint" writable="1"/>
+      <field name="padding1" type="gpointer"/>
+      <field name="underline" readable="1" type="guint" writable="1"/>
+      <field name="strikethrough" readable="1" type="guint" writable="1"/>
+      <field name="draw_bg" readable="1" type="guint" writable="1"/>
+      <field name="inside_selection" readable="1" type="guint" writable="1"/>
+      <field name="is_text" readable="1" type="guint" writable="1"/>
+      <field name="pad1" type="guint"/>
+      <field name="pad2" type="guint"/>
+      <field name="pad3" type="guint"/>
+      <field name="pad4" type="guint"/>
+    </struct>
+    <boxed get-type="" name="GtkTextAttributes" opaque="true" type-name="GtkTextAttributes">
+      <field access="public" name="refcount" type="guint" writeable="true"/>
+      <field access="public" name="appearance" readable="1" type="GtkTextAppearance" writable="1" writeable="true"/>
+      <field access="public" name="justification" readable="1" type="GtkJustification" writable="1" writeable="true"/>
+      <field access="public" name="direction" readable="1" type="GtkTextDirection" writable="1" writeable="true"/>
+      <field access="public" name="font" readable="1" type="PangoFontDescription*" writable="1" writeable="true"/>
+      <field access="public" name="font_scale" readable="1" type="gdouble" writable="1" writeable="true"/>
+      <field access="public" name="left_margin" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="indent" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="right_margin" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="pixels_above_lines" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="pixels_below_lines" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="pixels_inside_wrap" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="tabs" readable="1" type="PangoTabArray*" writable="1" writeable="true"/>
+      <field access="public" name="wrap_mode" readable="1" type="GtkWrapMode" writable="1" writeable="true"/>
+      <field access="public" name="language" readable="1" type="PangoLanguage*" writable="1" writeable="true"/>
+      <field access="public" name="pg_bg_color" type="GdkColor*" writeable="true"/>
+      <field access="public" name="invisible" readable="1" type="guint" writable="1" writeable="true"/>
+      <field access="public" name="bg_full_height" readable="1" type="guint" writable="1" writeable="true"/>
+      <field access="public" name="editable" readable="1" type="guint" writable="1" writeable="true"/>
+      <field access="public" name="realized" readable="1" type="guint" writable="1" writeable="true"/>
+      <field access="public" name="pad1" type="guint" writeable="true"/>
+      <field access="public" name="pad2" type="guint" writeable="true"/>
+      <field access="public" name="pad3" type="guint" writeable="true"/>
+      <field access="public" name="pad4" type="guint" writeable="true"/>
+      <method name="copy" symbol="gtk_text_attributes_copy">
+        <return-type type="GtkTextAttributes*"/>
+        <parameters>
+          <parameter name="src" type="GtkTextAttributes*"/>
+        </parameters>
+      </method>
+      <method name="copy_values" symbol="gtk_text_attributes_copy_values">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="src" type="GtkTextAttributes*"/>
+          <parameter name="dest" type="GtkTextAttributes*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_attributes_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="gtk_text_attributes_new">
+        <return-type type="GtkTextAttributes*"/>
+      </method>
+      <method name="ref" symbol="gtk_text_attributes_ref">
+        <return-type type="GtkTextAttributes*"/>
+        <parameters>
+          <parameter name="values" type="GtkTextAttributes*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="gtk_text_attributes_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="values" type="GtkTextAttributes*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkTextBTree" opaque="true" type-name="GtkTextBTree"/>
+    <boxed get-type="" name="GtkTextIter" type-name="GtkTextIter">
+      <field name="dummy1" type="gpointer"/>
+      <field name="dummy2" type="gpointer"/>
+      <field name="dummy3" type="gint"/>
+      <field name="dummy4" type="gint"/>
+      <field name="dummy5" type="gint"/>
+      <field name="dummy6" type="gint"/>
+      <field name="dummy7" type="gint"/>
+      <field name="dummy8" type="gint"/>
+      <field name="dummy9" type="gpointer"/>
+      <field name="dummy10" type="gpointer"/>
+      <field name="dummy11" type="gint"/>
+      <field name="dummy12" type="gint"/>
+      <field name="dummy13" type="gint"/>
+      <field name="dummy14" type="gpointer"/>
+      <method name="backward_char" symbol="gtk_text_iter_backward_char">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_chars" symbol="gtk_text_iter_backward_chars">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_cursor_position" symbol="gtk_text_iter_backward_cursor_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_cursor_positions" symbol="gtk_text_iter_backward_cursor_positions">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_find_char" symbol="gtk_text_iter_backward_find_char">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="pred" type="GtkTextCharPredicate"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="limit" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_line" symbol="gtk_text_iter_backward_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_lines" symbol="gtk_text_iter_backward_lines">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_search" symbol="gtk_text_iter_backward_search">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="str" type="const-gchar*"/>
+          <parameter name="flags" type="GtkTextSearchFlags"/>
+          <parameter name="match_start" type="GtkTextIter*"/>
+          <parameter name="match_end" type="GtkTextIter*"/>
+          <parameter name="limit" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_sentence_start" symbol="gtk_text_iter_backward_sentence_start">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_sentence_starts" symbol="gtk_text_iter_backward_sentence_starts">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_to_tag_toggle" symbol="gtk_text_iter_backward_to_tag_toggle">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="backward_visible_cursor_position" symbol="gtk_text_iter_backward_visible_cursor_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_visible_cursor_positions" symbol="gtk_text_iter_backward_visible_cursor_positions">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_visible_line" symbol="gtk_text_iter_backward_visible_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_visible_lines" symbol="gtk_text_iter_backward_visible_lines">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_visible_word_start" symbol="gtk_text_iter_backward_visible_word_start">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_visible_word_starts" symbol="gtk_text_iter_backward_visible_word_starts">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="backward_word_start" symbol="gtk_text_iter_backward_word_start">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="backward_word_starts" symbol="gtk_text_iter_backward_word_starts">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="begins_tag" symbol="gtk_text_iter_begins_tag">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="can_insert" symbol="gtk_text_iter_can_insert">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="default_editability" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="compare" symbol="gtk_text_iter_compare">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="lhs" type="const-GtkTextIter*"/>
+          <parameter name="rhs" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="gtk_text_iter_copy">
+        <return-type type="GtkTextIter*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="editable" symbol="gtk_text_iter_editable">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="default_setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="ends_line" symbol="gtk_text_iter_ends_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="ends_sentence" symbol="gtk_text_iter_ends_sentence">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="ends_tag" symbol="gtk_text_iter_ends_tag">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="ends_word" symbol="gtk_text_iter_ends_word">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="equal" symbol="gtk_text_iter_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="lhs" type="const-GtkTextIter*"/>
+          <parameter name="rhs" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_char" symbol="gtk_text_iter_forward_char">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_chars" symbol="gtk_text_iter_forward_chars">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_cursor_position" symbol="gtk_text_iter_forward_cursor_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_cursor_positions" symbol="gtk_text_iter_forward_cursor_positions">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_find_char" symbol="gtk_text_iter_forward_find_char">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="pred" type="GtkTextCharPredicate"/>
+          <parameter name="user_data" type="gpointer"/>
+          <parameter name="limit" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_line" symbol="gtk_text_iter_forward_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_lines" symbol="gtk_text_iter_forward_lines">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_search" symbol="gtk_text_iter_forward_search">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="str" type="const-gchar*"/>
+          <parameter name="flags" type="GtkTextSearchFlags"/>
+          <parameter name="match_start" type="GtkTextIter*"/>
+          <parameter name="match_end" type="GtkTextIter*"/>
+          <parameter name="limit" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_sentence_end" symbol="gtk_text_iter_forward_sentence_end">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_sentence_ends" symbol="gtk_text_iter_forward_sentence_ends">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_to_end" symbol="gtk_text_iter_forward_to_end">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_to_line_end" symbol="gtk_text_iter_forward_to_line_end">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_to_tag_toggle" symbol="gtk_text_iter_forward_to_tag_toggle">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="forward_visible_cursor_position" symbol="gtk_text_iter_forward_visible_cursor_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_visible_cursor_positions" symbol="gtk_text_iter_forward_visible_cursor_positions">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_visible_line" symbol="gtk_text_iter_forward_visible_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_visible_lines" symbol="gtk_text_iter_forward_visible_lines">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_visible_word_end" symbol="gtk_text_iter_forward_visible_word_end">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_visible_word_ends" symbol="gtk_text_iter_forward_visible_word_ends">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="forward_word_end" symbol="gtk_text_iter_forward_word_end">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="forward_word_ends" symbol="gtk_text_iter_forward_word_ends">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="count" type="gint"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_text_iter_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_attributes" symbol="gtk_text_iter_get_attributes">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="values" type="GtkTextAttributes*"/>
+        </parameters>
+      </method>
+      <method name="get_buffer" symbol="gtk_text_iter_get_buffer">
+        <return-type type="GtkTextBuffer*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_bytes_in_line" symbol="gtk_text_iter_get_bytes_in_line">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_char" symbol="gtk_text_iter_get_char">
+        <return-type type="gunichar"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_chars_in_line" symbol="gtk_text_iter_get_chars_in_line">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_child_anchor" symbol="gtk_text_iter_get_child_anchor">
+        <return-type type="GtkTextChildAnchor*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_language" symbol="gtk_text_iter_get_language">
+        <return-type type="PangoLanguage*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_line" symbol="gtk_text_iter_get_line">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_line_index" symbol="gtk_text_iter_get_line_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_line_offset" symbol="gtk_text_iter_get_line_offset">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_marks" symbol="gtk_text_iter_get_marks">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_offset" symbol="gtk_text_iter_get_offset">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_pixbuf" symbol="gtk_text_iter_get_pixbuf">
+        <return-type type="GdkPixbuf*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_slice" symbol="gtk_text_iter_get_slice">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_tags" symbol="gtk_text_iter_get_tags">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="gtk_text_iter_get_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_toggled_tags" symbol="gtk_text_iter_get_toggled_tags">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="toggled_on" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_text_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_visible_line_index" symbol="gtk_text_iter_get_visible_line_index">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_visible_line_offset" symbol="gtk_text_iter_get_visible_line_offset">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_visible_slice" symbol="gtk_text_iter_get_visible_slice">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="get_visible_text" symbol="gtk_text_iter_get_visible_text">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="has_tag" symbol="gtk_text_iter_has_tag">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+      <method name="in_range" symbol="gtk_text_iter_in_range">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="start" type="const-GtkTextIter*"/>
+          <parameter name="end" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="inside_sentence" symbol="gtk_text_iter_inside_sentence">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="inside_word" symbol="gtk_text_iter_inside_word">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="is_cursor_position" symbol="gtk_text_iter_is_cursor_position">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="is_end" symbol="gtk_text_iter_is_end">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="is_start" symbol="gtk_text_iter_is_start">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="order" symbol="gtk_text_iter_order">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="first" type="GtkTextIter*"/>
+          <parameter name="second" type="GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="set_line" symbol="gtk_text_iter_set_line">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="line_number" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_line_index" symbol="gtk_text_iter_set_line_index">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="byte_on_line" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_line_offset" symbol="gtk_text_iter_set_line_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="char_on_line" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_offset" symbol="gtk_text_iter_set_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="char_offset" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_visible_line_index" symbol="gtk_text_iter_set_visible_line_index">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="byte_on_line" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_visible_line_offset" symbol="gtk_text_iter_set_visible_line_offset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTextIter*"/>
+          <parameter name="char_on_line" type="gint"/>
+        </parameters>
+      </method>
+      <method name="starts_line" symbol="gtk_text_iter_starts_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="starts_sentence" symbol="gtk_text_iter_starts_sentence">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="starts_word" symbol="gtk_text_iter_starts_word">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+        </parameters>
+      </method>
+      <method name="toggles_tag" symbol="gtk_text_iter_toggles_tag">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="const-GtkTextIter*"/>
+          <parameter name="tag" type="GtkTextTag*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="GtkTextLogAttrCache" opaque="true" type-name="GtkTextLogAttrCache"/>
+    <struct get-type="" name="GtkTextPendingScroll" opaque="true" type-name="GtkTextPendingScroll"/>
+    <struct get-type="" name="GtkTextWindow" opaque="true" type-name="GtkTextWindow"/>
+    <struct get-type="" name="GtkThemeEngine" opaque="true" type-name="GtkThemeEngine"/>
+    <struct get-type="" name="GtkToggleActionEntry" type-name="GtkToggleActionEntry">
+      <field name="name" readable="1" type="const-gchar*" writable="1"/>
+      <field name="stock_id" readable="1" type="const-gchar*" writable="1"/>
+      <field name="label" readable="1" type="const-gchar*" writable="1"/>
+      <field name="accelerator" readable="1" type="const-gchar*" writable="1"/>
+      <field name="tooltip" readable="1" type="const-gchar*" writable="1"/>
+      <field name="callback" readable="1" type="GCallback" writable="1"/>
+      <field name="is_active" readable="1" type="gboolean" writable="1"/>
+    </struct>
+    <struct deprecated="1" get-type="" name="GtkToolbarChild" type-name="GtkToolbarChild">
+      <field name="type" readable="1" type="GtkToolbarChildType" writable="1"/>
+      <field name="widget" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="icon" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="label" readable="1" type="GtkWidget*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkTooltipsData" type-name="GtkTooltipsData">
+      <field name="tooltips" readable="1" type="GtkTooltips*" writable="1"/>
+      <field name="widget" readable="1" type="GtkWidget*" writable="1"/>
+      <field name="tip_text" readable="1" type="gchar*" writable="1"/>
+      <field name="tip_private" readable="1" type="gchar*" writable="1"/>
+      <method name="get" symbol="gtk_tooltips_data_get">
+        <return-type type="GtkTooltipsData*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </struct>
+    <boxed get-type="" name="GtkTreeIter" type-name="GtkTreeIter">
+      <field name="stamp" readable="1" type="gint" writable="1"/>
+      <field name="user_data" readable="1" type="gpointer" writable="1"/>
+      <field name="user_data2" readable="1" type="gpointer" writable="1"/>
+      <field name="user_data3" readable="1" type="gpointer" writable="1"/>
+      <method name="copy" symbol="gtk_tree_iter_copy">
+        <return-type type="GtkTreeIter*"/>
+        <parameters>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_tree_iter_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="GtkTreeIter*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+    </boxed>
+    <boxed get-type="" name="GtkTreePath" opaque="true" type-name="GtkTreePath">
+      <method name="append_index" symbol="gtk_tree_path_append_index">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="compare" symbol="gtk_tree_path_compare">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="a" type="const-GtkTreePath*"/>
+          <parameter name="b" type="const-GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="gtk_tree_path_copy">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="path" type="const-GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="down" symbol="gtk_tree_path_down">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_tree_path_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_depth" symbol="gtk_tree_path_get_depth">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_indices" symbol="gtk_tree_path_get_indices">
+        <return-type type="gint*"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_path_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_ancestor" symbol="gtk_tree_path_is_ancestor">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="descendant" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="is_descendant" symbol="gtk_tree_path_is_descendant">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="ancestor" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gtk_tree_path_new">
+        <return-type type="GtkTreePath*"/>
+      </method>
+      <method name="new_first" symbol="gtk_tree_path_new_first">
+        <return-type type="GtkTreePath*"/>
+      </method>
+      <method name="new_from_indices" symbol="gtk_tree_path_new_from_indices">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="first_index" type="gint"/>
+        </parameters>
+      </method>
+      <method name="new_from_string" symbol="gtk_tree_path_new_from_string">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="path" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="next" symbol="gtk_tree_path_next">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="prepend_index" symbol="gtk_tree_path_prepend_index">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="index_" type="gint"/>
+        </parameters>
+      </method>
+      <method name="prev" symbol="gtk_tree_path_prev">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="to_string" symbol="gtk_tree_path_to_string">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="up" symbol="gtk_tree_path_up">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="GtkTreeRowReference" opaque="true" type-name="GtkTreeRowReference">
+      <method name="copy" symbol="gtk_tree_row_reference_copy">
+        <return-type type="GtkTreeRowReference*"/>
+        <parameters>
+          <parameter name="reference" type="GtkTreeRowReference*"/>
+        </parameters>
+      </method>
+      <method name="deleted" symbol="gtk_tree_row_reference_deleted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="proxy" type="GObject*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="gtk_tree_row_reference_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="reference" type="GtkTreeRowReference*"/>
+        </parameters>
+      </method>
+      <method name="get_model" symbol="gtk_tree_row_reference_get_model">
+        <return-type type="GtkTreeModel*"/>
+        <parameters>
+          <parameter name="reference" type="GtkTreeRowReference*"/>
+        </parameters>
+      </method>
+      <method name="get_path" symbol="gtk_tree_row_reference_get_path">
+        <return-type type="GtkTreePath*"/>
+        <parameters>
+          <parameter name="reference" type="GtkTreeRowReference*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="gtk_tree_row_reference_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="inserted" symbol="gtk_tree_row_reference_inserted">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="proxy" type="GObject*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="gtk_tree_row_reference_new">
+        <return-type type="GtkTreeRowReference*"/>
+        <parameters>
+          <parameter name="model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="new_proxy" symbol="gtk_tree_row_reference_new_proxy">
+        <return-type type="GtkTreeRowReference*"/>
+        <parameters>
+          <parameter name="proxy" type="GObject*"/>
+          <parameter name="model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+      <method name="reordered" symbol="gtk_tree_row_reference_reordered">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="proxy" type="GObject*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+          <parameter name="iter" type="GtkTreeIter*"/>
+          <parameter name="new_order" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="valid" symbol="gtk_tree_row_reference_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="reference" type="GtkTreeRowReference*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct deprecated="1" get-type="" name="GtkTypeInfo" type-name="GtkTypeInfo">
+      <field name="type_name" readable="1" type="gchar*" writable="1"/>
+      <field name="object_size" readable="1" type="guint" writable="1"/>
+      <field name="class_size" readable="1" type="guint" writable="1"/>
+      <field name="class_init_func" readable="1" type="GtkClassInitFunc" writable="1"/>
+      <field name="object_init_func" readable="1" type="GtkObjectInitFunc" writable="1"/>
+      <field name="reserved_1" readable="1" type="gpointer" writable="1"/>
+      <field name="reserved_2" readable="1" type="gpointer" writable="1"/>
+      <field name="base_class_init_func" readable="1" type="GtkClassInitFunc" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkWidgetAuxInfo" type-name="GtkWidgetAuxInfo">
+      <field name="x" readable="1" type="gint" writable="1"/>
+      <field name="y" readable="1" type="gint" writable="1"/>
+      <field name="width" readable="1" type="gint" writable="1"/>
+      <field name="height" readable="1" type="gint" writable="1"/>
+      <field name="x_set" readable="1" type="guint" writable="1"/>
+      <field name="y_set" readable="1" type="guint" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkWidgetShapeInfo" type-name="GtkWidgetShapeInfo">
+      <field name="offset_x" readable="1" type="gint16" writable="1"/>
+      <field name="offset_y" readable="1" type="gint16" writable="1"/>
+      <field name="shape_mask" readable="1" type="GdkBitmap*" writable="1"/>
+    </struct>
+    <struct get-type="" name="GtkWindowGeometryInfo" opaque="true" type-name="GtkWindowGeometryInfo"/>
+    <struct name="GtkAccel">
+      <method name="groups_activate" symbol="gtk_accel_groups_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="object" type="GObject*"/>
+          <parameter name="accel_key" type="guint"/>
+          <parameter name="accel_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="groups_from_object" symbol="gtk_accel_groups_from_object">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="object" type="GObject*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkAccelerator">
+      <method name="get_default_mod_mask" symbol="gtk_accelerator_get_default_mod_mask">
+        <return-type type="guint"/>
+      </method>
+      <method name="get_label" symbol="gtk_accelerator_get_label">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="accelerator_key" type="guint"/>
+          <parameter name="accelerator_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="name" symbol="gtk_accelerator_name">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="accelerator_key" type="guint"/>
+          <parameter name="accelerator_mods" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="parse" symbol="gtk_accelerator_parse">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="accelerator" type="const-gchar*"/>
+          <parameter name="accelerator_key" type="guint*"/>
+          <parameter name="accelerator_mods" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+      <method name="set_default_mod_mask" symbol="gtk_accelerator_set_default_mod_mask">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="default_mod_mask" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="valid" symbol="gtk_accelerator_valid">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct cname="GtkGlobal" name="Global">
+      <method name="_alternative_dialog_button_order" symbol="gtk_alternative_dialog_button_order">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="screen" type="GdkScreen*"/>
+        </parameters>
+      </method>
+      <method name="_binding_parse_binding" symbol="gtk_binding_parse_binding">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="scanner" type="GScanner*"/>
+        </parameters>
+      </method>
+      <method name="_cell_type_get_type" symbol="gtk_cell_type_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="_check_version" symbol="gtk_check_version">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="required_major" type="guint"/>
+          <parameter name="required_minor" type="guint"/>
+          <parameter name="required_micro" type="guint"/>
+        </parameters>
+      </method>
+      <method name="_clist_drag_pos_get_type" symbol="gtk_clist_drag_pos_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="_disable_setlocale" symbol="gtk_disable_setlocale">
+        <return-type type="void"/>
+      </method>
+      <method name="_enumerate_printers" symbol="gtk_enumerate_printers">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="func" type="GtkPrinterFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GDestroyNotify"/>
+          <parameter name="wait" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_events_pending" symbol="gtk_events_pending">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="_get_current_event" symbol="gtk_get_current_event">
+        <return-type type="GdkEvent*"/>
+      </method>
+      <method name="_get_current_event_state" symbol="gtk_get_current_event_state">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="state" type="GdkModifierType*"/>
+        </parameters>
+      </method>
+      <method name="_get_current_event_time" symbol="gtk_get_current_event_time">
+        <return-type type="guint32"/>
+      </method>
+      <method name="_get_default_language" symbol="gtk_get_default_language">
+        <return-type type="PangoLanguage*"/>
+      </method>
+      <method name="_get_event_widget" symbol="gtk_get_event_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="_get_option_group" symbol="gtk_get_option_group">
+        <return-type type="GOptionGroup*"/>
+        <parameters>
+          <parameter name="open_default_display" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_identifier_get_type" symbol="gtk_identifier_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="_paint_arrow" symbol="gtk_paint_arrow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="arrow_type" type="GtkArrowType"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_box" symbol="gtk_paint_box">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_box_gap" symbol="gtk_paint_box_gap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+          <parameter name="gap_x" type="gint"/>
+          <parameter name="gap_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_check" symbol="gtk_paint_check">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_diamond" symbol="gtk_paint_diamond">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_expander" symbol="gtk_paint_expander">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="expander_style" type="GtkExpanderStyle"/>
+        </parameters>
+      </method>
+      <method name="_paint_extension" symbol="gtk_paint_extension">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+        </parameters>
+      </method>
+      <method name="_paint_flat_box" symbol="gtk_paint_flat_box">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_focus" symbol="gtk_paint_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_handle" symbol="gtk_paint_handle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </method>
+      <method name="_paint_hline" symbol="gtk_paint_hline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x1" type="gint"/>
+          <parameter name="x2" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_layout" symbol="gtk_paint_layout">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="use_text" type="gboolean"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="_paint_option" symbol="gtk_paint_option">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_polygon" symbol="gtk_paint_polygon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+          <parameter name="fill" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_paint_resize_grip" symbol="gtk_paint_resize_grip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="edge" type="GdkWindowEdge"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_shadow" symbol="gtk_paint_shadow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_shadow_gap" symbol="gtk_paint_shadow_gap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+          <parameter name="gap_x" type="gint"/>
+          <parameter name="gap_width" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_slider" symbol="gtk_paint_slider">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_paint_string" symbol="gtk_paint_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="_paint_tab" symbol="gtk_paint_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_paint_vline" symbol="gtk_paint_vline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="detail" type="const-gchar*"/>
+          <parameter name="y1_" type="gint"/>
+          <parameter name="y2_" type="gint"/>
+          <parameter name="x" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_parse_args" symbol="gtk_parse_args">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="argc" type="int*"/>
+          <parameter name="argv" type="char***"/>
+        </parameters>
+      </method>
+      <method name="_private_flags_get_type" symbol="gtk_private_flags_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="_propagate_event" symbol="gtk_propagate_event">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="_rgb_to_hsv" symbol="gtk_rgb_to_hsv">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="r" type="gdouble"/>
+          <parameter name="g" type="gdouble"/>
+          <parameter name="b" type="gdouble"/>
+          <parameter name="h" type="gdouble*"/>
+          <parameter name="s" type="gdouble*"/>
+          <parameter name="v" type="gdouble*"/>
+        </parameters>
+      </method>
+      <method name="_set_locale" symbol="gtk_set_locale">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="_show_about_dialog" symbol="gtk_show_about_dialog">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="first_property_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="_text_layout_draw" symbol="gtk_text_layout_draw">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="GtkTextLayout*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="cursor_gc" type="GdkGC*"/>
+          <parameter name="x_offset" type="gint"/>
+          <parameter name="y_offset" type="gint"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="widgets" type="GList**"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkBindings">
+      <method name="activate" symbol="gtk_bindings_activate">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="keyval" type="guint"/>
+          <parameter name="modifiers" type="GdkModifierType"/>
+        </parameters>
+      </method>
+      <method name="activate_event" symbol="gtk_bindings_activate_event">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="event" type="GdkEventKey*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkCtree">
+      <method name="expander_style_get_type" symbol="gtk_ctree_expander_style_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="expansion_type_get_type" symbol="gtk_ctree_expansion_type_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="line_style_get_type" symbol="gtk_ctree_line_style_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="pos_get_type" symbol="gtk_ctree_pos_get_type">
+        <return-type type="GType"/>
+      </method>
+    </struct>
+    <struct name="GtkDrag">
+      <method name="begin" symbol="gtk_drag_begin">
+        <return-type type="GdkDragContext*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="targets" type="GtkTargetList*"/>
+          <parameter name="actions" type="GdkDragAction"/>
+          <parameter name="button" type="gint"/>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="check_threshold" symbol="gtk_drag_check_threshold">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="start_x" type="gint"/>
+          <parameter name="start_y" type="gint"/>
+          <parameter name="current_x" type="gint"/>
+          <parameter name="current_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="dest_add_image_targets" symbol="gtk_drag_dest_add_image_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="dest_add_text_targets" symbol="gtk_drag_dest_add_text_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="dest_add_uri_targets" symbol="gtk_drag_dest_add_uri_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="dest_find_target" symbol="gtk_drag_dest_find_target">
+        <return-type type="GdkAtom"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="target_list" type="GtkTargetList*"/>
+        </parameters>
+      </method>
+      <method name="dest_get_target_list" symbol="gtk_drag_dest_get_target_list">
+        <return-type type="GtkTargetList*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="dest_get_track_motion" symbol="gtk_drag_dest_get_track_motion">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="dest_set" symbol="gtk_drag_dest_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="flags" type="GtkDestDefaults"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="actions" type="GdkDragAction"/>
+        </parameters>
+      </method>
+      <method name="dest_set_proxy" symbol="gtk_drag_dest_set_proxy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="proxy_window" type="GdkWindow*"/>
+          <parameter name="protocol" type="GdkDragProtocol"/>
+          <parameter name="use_coordinates" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="dest_set_target_list" symbol="gtk_drag_dest_set_target_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="target_list" type="GtkTargetList*"/>
+        </parameters>
+      </method>
+      <method name="dest_set_track_motion" symbol="gtk_drag_dest_set_track_motion">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="track_motion" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="dest_unset" symbol="gtk_drag_dest_unset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="finish" symbol="gtk_drag_finish">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="success" type="gboolean"/>
+          <parameter name="del" type="gboolean"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="get_data" symbol="gtk_drag_get_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="get_source_widget" symbol="gtk_drag_get_source_widget">
+        <return-type type="GtkWidget*"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </method>
+      <method name="highlight" symbol="gtk_drag_highlight">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="set_default_icon" symbol="gtk_drag_set_default_icon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+          <parameter name="hot_x" type="gint"/>
+          <parameter name="hot_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_icon_default" symbol="gtk_drag_set_icon_default">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+        </parameters>
+      </method>
+      <method name="set_icon_name" symbol="gtk_drag_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+          <parameter name="hot_x" type="gint"/>
+          <parameter name="hot_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_icon_pixbuf" symbol="gtk_drag_set_icon_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+          <parameter name="hot_x" type="gint"/>
+          <parameter name="hot_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_icon_pixmap" symbol="gtk_drag_set_icon_pixmap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+          <parameter name="hot_x" type="gint"/>
+          <parameter name="hot_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_icon_stock" symbol="gtk_drag_set_icon_stock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="hot_x" type="gint"/>
+          <parameter name="hot_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_icon_widget" symbol="gtk_drag_set_icon_widget">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="GdkDragContext*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="hot_x" type="gint"/>
+          <parameter name="hot_y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="source_add_image_targets" symbol="gtk_drag_source_add_image_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="source_add_text_targets" symbol="gtk_drag_source_add_text_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="source_add_uri_targets" symbol="gtk_drag_source_add_uri_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="source_get_target_list" symbol="gtk_drag_source_get_target_list">
+        <return-type type="GtkTargetList*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="source_set" symbol="gtk_drag_source_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="start_button_mask" type="GdkModifierType"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="actions" type="GdkDragAction"/>
+        </parameters>
+      </method>
+      <method name="source_set_icon" symbol="gtk_drag_source_set_icon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="pixmap" type="GdkPixmap*"/>
+          <parameter name="mask" type="GdkBitmap*"/>
+        </parameters>
+      </method>
+      <method name="source_set_icon_name" symbol="gtk_drag_source_set_icon_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="icon_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="source_set_icon_pixbuf" symbol="gtk_drag_source_set_icon_pixbuf">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="pixbuf" type="GdkPixbuf*"/>
+        </parameters>
+      </method>
+      <method name="source_set_icon_stock" symbol="gtk_drag_source_set_icon_stock">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="stock_id" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="source_set_target_list" symbol="gtk_drag_source_set_target_list">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="target_list" type="GtkTargetList*"/>
+        </parameters>
+      </method>
+      <method name="source_unset" symbol="gtk_drag_source_unset">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="unhighlight" symbol="gtk_drag_unhighlight">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkDraw">
+      <method deprecated="1" name="arrow" symbol="gtk_draw_arrow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="arrow_type" type="GtkArrowType"/>
+          <parameter name="fill" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="box" symbol="gtk_draw_box">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="box_gap" symbol="gtk_draw_box_gap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+          <parameter name="gap_x" type="gint"/>
+          <parameter name="gap_width" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="check" symbol="gtk_draw_check">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="diamond" symbol="gtk_draw_diamond">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="expander" symbol="gtk_draw_expander">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="expander_style" type="GtkExpanderStyle"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="extension" symbol="gtk_draw_extension">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="flat_box" symbol="gtk_draw_flat_box">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="focus" symbol="gtk_draw_focus">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="handle" symbol="gtk_draw_handle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="hline" symbol="gtk_draw_hline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="x1" type="gint"/>
+          <parameter name="x2" type="gint"/>
+          <parameter name="y" type="gint"/>
+        </parameters>
+      </method>
+      <method name="insertion_cursor" symbol="gtk_draw_insertion_cursor">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="drawable" type="GdkDrawable*"/>
+          <parameter name="area" type="GdkRectangle*"/>
+          <parameter name="location" type="GdkRectangle*"/>
+          <parameter name="is_primary" type="gboolean"/>
+          <parameter name="direction" type="GtkTextDirection"/>
+          <parameter name="draw_arrow" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="layout" symbol="gtk_draw_layout">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="use_text" type="gboolean"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="option" symbol="gtk_draw_option">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="polygon" symbol="gtk_draw_polygon">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="points" type="GdkPoint*"/>
+          <parameter name="npoints" type="gint"/>
+          <parameter name="fill" type="gboolean"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="resize_grip" symbol="gtk_draw_resize_grip">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="edge" type="GdkWindowEdge"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="shadow" symbol="gtk_draw_shadow">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="shadow_gap" symbol="gtk_draw_shadow_gap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="gap_side" type="GtkPositionType"/>
+          <parameter name="gap_x" type="gint"/>
+          <parameter name="gap_width" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="slider" symbol="gtk_draw_slider">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+          <parameter name="orientation" type="GtkOrientation"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="string" symbol="gtk_draw_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="tab" symbol="gtk_draw_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="shadow_type" type="GtkShadowType"/>
+          <parameter name="x" type="gint"/>
+          <parameter name="y" type="gint"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="vline" symbol="gtk_draw_vline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="style" type="GtkStyle*"/>
+          <parameter name="window" type="GdkWindow*"/>
+          <parameter name="state_type" type="GtkStateType"/>
+          <parameter name="y1_" type="gint"/>
+          <parameter name="y2_" type="gint"/>
+          <parameter name="x" type="gint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkGc">
+      <method name="get" symbol="gtk_gc_get">
+        <return-type type="GdkGC*"/>
+        <parameters>
+          <parameter name="depth" type="gint"/>
+          <parameter name="colormap" type="GdkColormap*"/>
+          <parameter name="values" type="GdkGCValues*"/>
+          <parameter name="values_mask" type="GdkGCValuesMask"/>
+        </parameters>
+      </method>
+      <method name="release" symbol="gtk_gc_release">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="gc" type="GdkGC*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkGrab">
+      <method name="add" symbol="gtk_grab_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_current" symbol="gtk_grab_get_current">
+        <return-type type="GtkWidget*"/>
+      </method>
+      <method name="remove" symbol="gtk_grab_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkIcon">
+      <method name="size_from_name" symbol="gtk_icon_size_from_name">
+        <return-type type="GtkIconSize"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="size_get_name" symbol="gtk_icon_size_get_name">
+        <return-type type="const-gchar*"/>
+        <parameters>
+          <parameter name="size" type="GtkIconSize"/>
+        </parameters>
+      </method>
+      <method name="size_lookup" symbol="gtk_icon_size_lookup">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="size" type="GtkIconSize"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="size_lookup_for_settings" symbol="gtk_icon_size_lookup_for_settings">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="size" type="GtkIconSize"/>
+          <parameter name="width" type="gint*"/>
+          <parameter name="height" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="size_register" symbol="gtk_icon_size_register">
+        <return-type type="GtkIconSize"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="width" type="gint"/>
+          <parameter name="height" type="gint"/>
+        </parameters>
+      </method>
+      <method name="size_register_alias" symbol="gtk_icon_size_register_alias">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="alias" type="const-gchar*"/>
+          <parameter name="target" type="GtkIconSize"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkIdle">
+      <method deprecated="1" name="add" symbol="gtk_idle_add">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="add_full" symbol="gtk_idle_add_full">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="priority" type="gint"/>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="marshal" type="GtkCallbackMarshal"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="add_priority" symbol="gtk_idle_add_priority">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="priority" type="gint"/>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove" symbol="gtk_idle_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="idle_handler_id" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove_by_data" symbol="gtk_idle_remove_by_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkInit">
+      <method name="abi_check" symbol="gtk_init_abi_check">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="argc" type="int*"/>
+          <parameter name="argv" type="char***"/>
+          <parameter name="num_checks" type="int"/>
+          <parameter name="sizeof_GtkWindow" type="size_t"/>
+          <parameter name="sizeof_GtkBox" type="size_t"/>
+        </parameters>
+      </method>
+      <method name="add" symbol="gtk_init_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="check" symbol="gtk_init_check">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="argc" type="int*"/>
+          <parameter name="argv" type="char***"/>
+        </parameters>
+      </method>
+      <method name="check_abi_check" symbol="gtk_init_check_abi_check">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="argc" type="int*"/>
+          <parameter name="argv" type="char***"/>
+          <parameter name="num_checks" type="int"/>
+          <parameter name="sizeof_GtkWindow" type="size_t"/>
+          <parameter name="sizeof_GtkBox" type="size_t"/>
+        </parameters>
+      </method>
+      <method name="with_args" symbol="gtk_init_with_args">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="argc" type="int*"/>
+          <parameter name="argv" type="char***"/>
+          <parameter name="parameter_string" type="char*"/>
+          <parameter name="entries" type="GOptionEntry*"/>
+          <parameter name="translation_domain" type="char*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkInput">
+      <method deprecated="1" name="add_full" symbol="gtk_input_add_full">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="source" type="gint"/>
+          <parameter name="condition" type="GdkInputCondition"/>
+          <parameter name="function" type="GdkInputFunction"/>
+          <parameter name="marshal" type="GtkCallbackMarshal"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove" symbol="gtk_input_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="input_handler_id" type="guint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkKey">
+      <method name="snooper_install" symbol="gtk_key_snooper_install">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="snooper" type="GtkKeySnoopFunc"/>
+          <parameter name="func_data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="snooper_remove" symbol="gtk_key_snooper_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="snooper_handler_id" type="guint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkMain">
+      <method name="do_event" symbol="gtk_main_do_event">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="event" type="GdkEvent*"/>
+        </parameters>
+      </method>
+      <method name="iteration" symbol="gtk_main_iteration">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="iteration_do" symbol="gtk_main_iteration_do">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="blocking" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="level" symbol="gtk_main_level">
+        <return-type type="guint"/>
+      </method>
+      <method name="quit" symbol="gtk_main_quit">
+        <return-type type="void"/>
+      </method>
+    </struct>
+    <struct name="GtkPrint">
+      <method name="error_quark" symbol="gtk_print_error_quark">
+        <return-type type="GQuark"/>
+      </method>
+      <method name="run_page_setup_dialog" symbol="gtk_print_run_page_setup_dialog">
+        <return-type type="GtkPageSetup*"/>
+        <parameters>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+        </parameters>
+      </method>
+      <method name="run_page_setup_dialog_async" symbol="gtk_print_run_page_setup_dialog_async">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="parent" type="GtkWindow*"/>
+          <parameter name="page_setup" type="GtkPageSetup*"/>
+          <parameter name="settings" type="GtkPrintSettings*"/>
+          <parameter name="done_cb" type="GtkPageSetupDoneFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkQuit">
+      <method name="add" symbol="gtk_quit_add">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="main_level" type="guint"/>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="add_destroy" symbol="gtk_quit_add_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="main_level" type="guint"/>
+          <parameter name="object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method name="add_full" symbol="gtk_quit_add_full">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="main_level" type="guint"/>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="marshal" type="GtkCallbackMarshal"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method name="remove" symbol="gtk_quit_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="quit_handler_id" type="guint"/>
+        </parameters>
+      </method>
+      <method name="remove_by_data" symbol="gtk_quit_remove_by_data">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkRc">
+      <method deprecated="1" name="add_class_style" symbol="gtk_rc_add_class_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="add_default_file" symbol="gtk_rc_add_default_file">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="add_widget_class_style" symbol="gtk_rc_add_widget_class_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="add_widget_name_style" symbol="gtk_rc_add_widget_name_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="rc_style" type="GtkRcStyle*"/>
+          <parameter name="pattern" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="find_module_in_path" symbol="gtk_rc_find_module_in_path">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="module_file" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="find_pixmap_in_path" symbol="gtk_rc_find_pixmap_in_path">
+        <return-type type="gchar*"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="scanner" type="GScanner*"/>
+          <parameter name="pixmap_file" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="get_default_files" symbol="gtk_rc_get_default_files">
+        <return-type type="gchar**"/>
+      </method>
+      <method name="get_im_module_file" symbol="gtk_rc_get_im_module_file">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="get_im_module_path" symbol="gtk_rc_get_im_module_path">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="get_module_dir" symbol="gtk_rc_get_module_dir">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="get_style" symbol="gtk_rc_get_style">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+      <method name="get_style_by_paths" symbol="gtk_rc_get_style_by_paths">
+        <return-type type="GtkStyle*"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="widget_path" type="const-char*"/>
+          <parameter name="class_path" type="const-char*"/>
+          <parameter name="type" type="GType"/>
+        </parameters>
+      </method>
+      <method name="get_theme_dir" symbol="gtk_rc_get_theme_dir">
+        <return-type type="gchar*"/>
+      </method>
+      <method name="parse" symbol="gtk_rc_parse">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filename" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="parse_color" symbol="gtk_rc_parse_color">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="scanner" type="GScanner*"/>
+          <parameter name="color" type="GdkColor*"/>
+        </parameters>
+      </method>
+      <method name="parse_priority" symbol="gtk_rc_parse_priority">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="scanner" type="GScanner*"/>
+          <parameter name="priority" type="GtkPathPriorityType*"/>
+        </parameters>
+      </method>
+      <method name="parse_state" symbol="gtk_rc_parse_state">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="scanner" type="GScanner*"/>
+          <parameter name="state" type="GtkStateType*"/>
+        </parameters>
+      </method>
+      <method name="parse_string" symbol="gtk_rc_parse_string">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="rc_string" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="reparse_all" symbol="gtk_rc_reparse_all">
+        <return-type type="gboolean"/>
+      </method>
+      <method name="reparse_all_for_settings" symbol="gtk_rc_reparse_all_for_settings">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+          <parameter name="force_load" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="reset_styles" symbol="gtk_rc_reset_styles">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="settings" type="GtkSettings*"/>
+        </parameters>
+      </method>
+      <method name="scanner_new" symbol="gtk_rc_scanner_new">
+        <return-type type="GScanner*"/>
+      </method>
+      <method name="set_default_files" symbol="gtk_rc_set_default_files">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="filenames" type="gchar**"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkSelection">
+      <method name="add_target" symbol="gtk_selection_add_target">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="info" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_targets" symbol="gtk_selection_add_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="targets" type="const-GtkTargetEntry*"/>
+          <parameter name="ntargets" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="clear" symbol="gtk_selection_clear">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="event" type="GdkEventSelection*"/>
+        </parameters>
+      </method>
+      <method name="clear_targets" symbol="gtk_selection_clear_targets">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+        </parameters>
+      </method>
+      <method name="convert" symbol="gtk_selection_convert">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="target" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="owner_set" symbol="gtk_selection_owner_set">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="owner_set_for_display" symbol="gtk_selection_owner_set_for_display">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="display" type="GdkDisplay*"/>
+          <parameter name="widget" type="GtkWidget*"/>
+          <parameter name="selection" type="GdkAtom"/>
+          <parameter name="time_" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="remove_all" symbol="gtk_selection_remove_all">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="widget" type="GtkWidget*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkSignal">
+      <method deprecated="1" name="compat_matched" symbol="gtk_signal_compat_matched">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="func" type="GtkSignalFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="match" type="GSignalMatchType"/>
+          <parameter name="action" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="connect_full" symbol="gtk_signal_connect_full">
+        <return-type type="gulong"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="func" type="GtkSignalFunc"/>
+          <parameter name="unsupported" type="GtkCallbackMarshal"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy_func" type="GtkDestroyNotify"/>
+          <parameter name="object_signal" type="gint"/>
+          <parameter name="after" type="gint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="connect_object_while_alive" symbol="gtk_signal_connect_object_while_alive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="func" type="GtkSignalFunc"/>
+          <parameter name="alive_object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="connect_while_alive" symbol="gtk_signal_connect_while_alive">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="func" type="GtkSignalFunc"/>
+          <parameter name="func_data" type="gpointer"/>
+          <parameter name="alive_object" type="GtkObject*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="emit" symbol="gtk_signal_emit">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="signal_id" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="emit_by_name" symbol="gtk_signal_emit_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="emit_stop_by_name" symbol="gtk_signal_emit_stop_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="emitv" symbol="gtk_signal_emitv">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="signal_id" type="guint"/>
+          <parameter name="args" type="GtkArg*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="emitv_by_name" symbol="gtk_signal_emitv_by_name">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="object" type="GtkObject*"/>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="args" type="GtkArg*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="new" symbol="gtk_signal_new">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="signal_flags" type="GtkSignalRunType"/>
+          <parameter name="object_type" type="GtkType"/>
+          <parameter name="function_offset" type="guint"/>
+          <parameter name="marshaller" type="GtkSignalMarshaller"/>
+          <parameter name="return_val" type="GtkType"/>
+          <parameter name="n_args" type="guint"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="newv" symbol="gtk_signal_newv">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+          <parameter name="signal_flags" type="GtkSignalRunType"/>
+          <parameter name="object_type" type="GtkType"/>
+          <parameter name="function_offset" type="guint"/>
+          <parameter name="marshaller" type="GtkSignalMarshaller"/>
+          <parameter name="return_val" type="GtkType"/>
+          <parameter name="n_args" type="guint"/>
+          <parameter name="args" type="GtkType*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkStock">
+      <method name="add" symbol="gtk_stock_add">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="items" type="const-GtkStockItem*"/>
+          <parameter name="n_items" type="guint"/>
+        </parameters>
+      </method>
+      <method name="add_static" symbol="gtk_stock_add_static">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="items" type="const-GtkStockItem*"/>
+          <parameter name="n_items" type="guint"/>
+        </parameters>
+      </method>
+      <method name="list_ids" symbol="gtk_stock_list_ids">
+        <return-type type="GSList*"/>
+      </method>
+      <method name="lookup" symbol="gtk_stock_lookup">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="stock_id" type="const-gchar*"/>
+          <parameter name="item" type="GtkStockItem*"/>
+        </parameters>
+      </method>
+      <method name="set_translate_func" symbol="gtk_stock_set_translate_func">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="domain" type="const-gchar*"/>
+          <parameter name="func" type="GtkTranslateFunc"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="notify" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkTarget">
+      <method name="table_free" symbol="gtk_target_table_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="targets" type="GtkTargetEntry*"/>
+          <parameter name="n_targets" type="gint"/>
+        </parameters>
+      </method>
+      <method name="table_new_from_list" symbol="gtk_target_table_new_from_list">
+        <return-type type="GtkTargetEntry*"/>
+        <parameters>
+          <parameter name="list" type="GtkTargetList*"/>
+          <parameter name="n_targets" type="gint*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkTargets">
+      <method name="include_image" symbol="gtk_targets_include_image">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="targets" type="GdkAtom*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="writable" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="include_rich_text" symbol="gtk_targets_include_rich_text">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="targets" type="GdkAtom*"/>
+          <parameter name="n_targets" type="gint"/>
+          <parameter name="buffer" type="GtkTextBuffer*"/>
+        </parameters>
+      </method>
+      <method name="include_text" symbol="gtk_targets_include_text">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="targets" type="GdkAtom*"/>
+          <parameter name="n_targets" type="gint"/>
+        </parameters>
+      </method>
+      <method name="include_uri" symbol="gtk_targets_include_uri">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="targets" type="GdkAtom*"/>
+          <parameter name="n_targets" type="gint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkTimeout">
+      <method deprecated="1" name="add" symbol="gtk_timeout_add">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="interval" type="guint32"/>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="add_full" symbol="gtk_timeout_add_full">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="interval" type="guint32"/>
+          <parameter name="function" type="GtkFunction"/>
+          <parameter name="marshal" type="GtkCallbackMarshal"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="destroy" type="GtkDestroyNotify"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="remove" symbol="gtk_timeout_remove">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="timeout_handler_id" type="guint"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkTree">
+      <method name="get_row_drag_data" symbol="gtk_tree_get_row_drag_data">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="tree_model" type="GtkTreeModel**"/>
+          <parameter name="path" type="GtkTreePath**"/>
+        </parameters>
+      </method>
+      <method name="set_row_drag_data" symbol="gtk_tree_set_row_drag_data">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="selection_data" type="GtkSelectionData*"/>
+          <parameter name="tree_model" type="GtkTreeModel*"/>
+          <parameter name="path" type="GtkTreePath*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="GtkType">
+      <method name="class" symbol="gtk_type_class">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="type" type="GtkType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="enum_find_value" symbol="gtk_type_enum_find_value">
+        <return-type type="GtkEnumValue*"/>
+        <parameters>
+          <parameter name="enum_type" type="GtkType"/>
+          <parameter name="value_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="enum_get_values" symbol="gtk_type_enum_get_values">
+        <return-type type="GtkEnumValue*"/>
+        <parameters>
+          <parameter name="enum_type" type="GtkType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="flags_find_value" symbol="gtk_type_flags_find_value">
+        <return-type type="GtkFlagValue*"/>
+        <parameters>
+          <parameter name="flags_type" type="GtkType"/>
+          <parameter name="value_name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="flags_get_values" symbol="gtk_type_flags_get_values">
+        <return-type type="GtkFlagValue*"/>
+        <parameters>
+          <parameter name="flags_type" type="GtkType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="init" symbol="gtk_type_init">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="debug_flags" type="GTypeDebugFlags"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="new" symbol="gtk_type_new">
+        <return-type type="gpointer"/>
+        <parameters>
+          <parameter name="type" type="GtkType"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="unique" symbol="gtk_type_unique">
+        <return-type type="GtkType"/>
+        <parameters>
+          <parameter name="parent_type" type="GtkType"/>
+          <parameter name="gtkinfo" type="const-GtkTypeInfo*"/>
+        </parameters>
+      </method>
+    </struct>
+    <constant name="GTK_STOCK_ABOUT" type="utf8" type-name="GTK_STOCK_ABOUT" value="gtk-about"/>
+    <constant name="GTK_STOCK_ADD" type="utf8" type-name="GTK_STOCK_ADD" value="gtk-add"/>
+    <constant name="GTK_STOCK_APPLY" type="utf8" type-name="GTK_STOCK_APPLY" value="gtk-apply"/>
+    <constant name="GTK_STOCK_BOLD" type="utf8" type-name="GTK_STOCK_BOLD" value="gtk-bold"/>
+    <constant name="GTK_STOCK_CANCEL" type="utf8" type-name="GTK_STOCK_CANCEL" value="gtk-cancel"/>
+    <constant name="GTK_STOCK_CDROM" type="utf8" type-name="GTK_STOCK_CDROM" value="gtk-cdrom"/>
+    <constant name="GTK_STOCK_CLEAR" type="utf8" type-name="GTK_STOCK_CLEAR" value="gtk-clear"/>
+    <constant name="GTK_STOCK_CLOSE" type="utf8" type-name="GTK_STOCK_CLOSE" value="gtk-close"/>
+    <constant name="GTK_STOCK_COLOR_PICKER" type="utf8" type-name="GTK_STOCK_COLOR_PICKER" value="gtk-color-picker"/>
+    <constant name="GTK_STOCK_CONNECT" type="utf8" type-name="GTK_STOCK_CONNECT" value="gtk-connect"/>
+    <constant name="GTK_STOCK_CONVERT" type="utf8" type-name="GTK_STOCK_CONVERT" value="gtk-convert"/>
+    <constant name="GTK_STOCK_COPY" type="utf8" type-name="GTK_STOCK_COPY" value="gtk-copy"/>
+    <constant name="GTK_STOCK_CUT" type="utf8" type-name="GTK_STOCK_CUT" value="gtk-cut"/>
+    <constant name="GTK_STOCK_DELETE" type="utf8" type-name="GTK_STOCK_DELETE" value="gtk-delete"/>
+    <constant name="GTK_STOCK_DIALOG_ERROR" type="utf8" type-name="GTK_STOCK_DIALOG_ERROR" value="gtk-dialog-error"/>
+    <constant name="GTK_STOCK_DIALOG_INFO" type="utf8" type-name="GTK_STOCK_DIALOG_INFO" value="gtk-dialog-info"/>
+    <constant name="GTK_STOCK_DIALOG_QUESTION" type="utf8" type-name="GTK_STOCK_DIALOG_QUESTION" value="gtk-dialog-question"/>
+    <constant name="GTK_STOCK_DIALOG_WARNING" type="utf8" type-name="GTK_STOCK_DIALOG_WARNING" value="gtk-dialog-warning"/>
+    <constant name="GTK_STOCK_DIRECTORY" type="utf8" type-name="GTK_STOCK_DIRECTORY" value="gtk-directory"/>
+    <constant name="GTK_STOCK_DISCONNECT" type="utf8" type-name="GTK_STOCK_DISCONNECT" value="gtk-disconnect"/>
+    <constant name="GTK_STOCK_DND" type="utf8" type-name="GTK_STOCK_DND" value="gtk-dnd"/>
+    <constant name="GTK_STOCK_DND_MULTIPLE" type="utf8" type-name="GTK_STOCK_DND_MULTIPLE" value="gtk-dnd-multiple"/>
+    <constant name="GTK_STOCK_EDIT" type="utf8" type-name="GTK_STOCK_EDIT" value="gtk-edit"/>
+    <constant name="GTK_STOCK_EXECUTE" type="utf8" type-name="GTK_STOCK_EXECUTE" value="gtk-execute"/>
+    <constant name="GTK_STOCK_FILE" type="utf8" type-name="GTK_STOCK_FILE" value="gtk-file"/>
+    <constant name="GTK_STOCK_FIND" type="utf8" type-name="GTK_STOCK_FIND" value="gtk-find"/>
+    <constant name="GTK_STOCK_FIND_AND_REPLACE" type="utf8" type-name="GTK_STOCK_FIND_AND_REPLACE" value="gtk-find-and-replace"/>
+    <constant name="GTK_STOCK_FLOPPY" type="utf8" type-name="GTK_STOCK_FLOPPY" value="gtk-floppy"/>
+    <constant name="GTK_STOCK_FULLSCREEN" type="utf8" type-name="GTK_STOCK_FULLSCREEN" value="gtk-fullscreen"/>
+    <constant name="GTK_STOCK_GOTO_BOTTOM" type="utf8" type-name="GTK_STOCK_GOTO_BOTTOM" value="gtk-goto-bottom"/>
+    <constant name="GTK_STOCK_GOTO_FIRST" type="utf8" type-name="GTK_STOCK_GOTO_FIRST" value="gtk-goto-first"/>
+    <constant name="GTK_STOCK_GOTO_LAST" type="utf8" type-name="GTK_STOCK_GOTO_LAST" value="gtk-goto-last"/>
+    <constant name="GTK_STOCK_GOTO_TOP" type="utf8" type-name="GTK_STOCK_GOTO_TOP" value="gtk-goto-top"/>
+    <constant name="GTK_STOCK_GO_BACK" type="utf8" type-name="GTK_STOCK_GO_BACK" value="gtk-go-back"/>
+    <constant name="GTK_STOCK_GO_DOWN" type="utf8" type-name="GTK_STOCK_GO_DOWN" value="gtk-go-down"/>
+    <constant name="GTK_STOCK_GO_FORWARD" type="utf8" type-name="GTK_STOCK_GO_FORWARD" value="gtk-go-forward"/>
+    <constant name="GTK_STOCK_GO_UP" type="utf8" type-name="GTK_STOCK_GO_UP" value="gtk-go-up"/>
+    <constant name="GTK_STOCK_HARDDISK" type="utf8" type-name="GTK_STOCK_HARDDISK" value="gtk-harddisk"/>
+    <constant name="GTK_STOCK_HELP" type="utf8" type-name="GTK_STOCK_HELP" value="gtk-help"/>
+    <constant name="GTK_STOCK_HOME" type="utf8" type-name="GTK_STOCK_HOME" value="gtk-home"/>
+    <constant name="GTK_STOCK_INDENT" type="utf8" type-name="GTK_STOCK_INDENT" value="gtk-indent"/>
+    <constant name="GTK_STOCK_INDEX" type="utf8" type-name="GTK_STOCK_INDEX" value="gtk-index"/>
+    <constant name="GTK_STOCK_INFO" type="utf8" type-name="GTK_STOCK_INFO" value="gtk-info"/>
+    <constant name="GTK_STOCK_ITALIC" type="utf8" type-name="GTK_STOCK_ITALIC" value="gtk-italic"/>
+    <constant name="GTK_STOCK_JUMP_TO" type="utf8" type-name="GTK_STOCK_JUMP_TO" value="gtk-jump-to"/>
+    <constant name="GTK_STOCK_JUSTIFY_CENTER" type="utf8" type-name="GTK_STOCK_JUSTIFY_CENTER" value="gtk-justify-center"/>
+    <constant name="GTK_STOCK_JUSTIFY_FILL" type="utf8" type-name="GTK_STOCK_JUSTIFY_FILL" value="gtk-justify-fill"/>
+    <constant name="GTK_STOCK_JUSTIFY_LEFT" type="utf8" type-name="GTK_STOCK_JUSTIFY_LEFT" value="gtk-justify-left"/>
+    <constant name="GTK_STOCK_JUSTIFY_RIGHT" type="utf8" type-name="GTK_STOCK_JUSTIFY_RIGHT" value="gtk-justify-right"/>
+    <constant name="GTK_STOCK_LEAVE_FULLSCREEN" type="utf8" type-name="GTK_STOCK_LEAVE_FULLSCREEN" value="gtk-leave-fullscreen"/>
+    <constant name="GTK_STOCK_MEDIA_FORWARD" type="utf8" type-name="GTK_STOCK_MEDIA_FORWARD" value="gtk-media-forward"/>
+    <constant name="GTK_STOCK_MEDIA_NEXT" type="utf8" type-name="GTK_STOCK_MEDIA_NEXT" value="gtk-media-next"/>
+    <constant name="GTK_STOCK_MEDIA_PAUSE" type="utf8" type-name="GTK_STOCK_MEDIA_PAUSE" value="gtk-media-pause"/>
+    <constant name="GTK_STOCK_MEDIA_PLAY" type="utf8" type-name="GTK_STOCK_MEDIA_PLAY" value="gtk-media-play"/>
+    <constant name="GTK_STOCK_MEDIA_PREVIOUS" type="utf8" type-name="GTK_STOCK_MEDIA_PREVIOUS" value="gtk-media-previous"/>
+    <constant name="GTK_STOCK_MEDIA_RECORD" type="utf8" type-name="GTK_STOCK_MEDIA_RECORD" value="gtk-media-record"/>
+    <constant name="GTK_STOCK_MEDIA_REWIND" type="utf8" type-name="GTK_STOCK_MEDIA_REWIND" value="gtk-media-rewind"/>
+    <constant name="GTK_STOCK_MEDIA_STOP" type="utf8" type-name="GTK_STOCK_MEDIA_STOP" value="gtk-media-stop"/>
+    <constant name="GTK_STOCK_MISSING_IMAGE" type="utf8" type-name="GTK_STOCK_MISSING_IMAGE" value="gtk-missing-image"/>
+    <constant name="GTK_STOCK_NETWORK" type="utf8" type-name="GTK_STOCK_NETWORK" value="gtk-network"/>
+    <constant name="GTK_STOCK_NEW" type="utf8" type-name="GTK_STOCK_NEW" value="gtk-new"/>
+    <constant name="GTK_STOCK_NO" type="utf8" type-name="GTK_STOCK_NO" value="gtk-no"/>
+    <constant name="GTK_STOCK_OK" type="utf8" type-name="GTK_STOCK_OK" value="gtk-ok"/>
+    <constant name="GTK_STOCK_OPEN" type="utf8" type-name="GTK_STOCK_OPEN" value="gtk-open"/>
+    <constant name="GTK_STOCK_ORIENTATION_LANDSCAPE" type="utf8" type-name="GTK_STOCK_ORIENTATION_LANDSCAPE" value="gtk-orientation-landscape"/>
+    <constant name="GTK_STOCK_ORIENTATION_PORTRAIT" type="utf8" type-name="GTK_STOCK_ORIENTATION_PORTRAIT" value="gtk-orientation-portrait"/>
+    <constant name="GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE" type="utf8" type-name="GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE" value="gtk-orientation-reverse-landscape"/>
+    <constant name="GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT" type="utf8" type-name="GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT" value="gtk-orientation-reverse-portrait"/>
+    <constant name="GTK_STOCK_PASTE" type="utf8" type-name="GTK_STOCK_PASTE" value="gtk-paste"/>
+    <constant name="GTK_STOCK_PREFERENCES" type="utf8" type-name="GTK_STOCK_PREFERENCES" value="gtk-preferences"/>
+    <constant name="GTK_STOCK_PRINT" type="utf8" type-name="GTK_STOCK_PRINT" value="gtk-print"/>
+    <constant name="GTK_STOCK_PRINT_PREVIEW" type="utf8" type-name="GTK_STOCK_PRINT_PREVIEW" value="gtk-print-preview"/>
+    <constant name="GTK_STOCK_PROPERTIES" type="utf8" type-name="GTK_STOCK_PROPERTIES" value="gtk-properties"/>
+    <constant name="GTK_STOCK_QUIT" type="utf8" type-name="GTK_STOCK_QUIT" value="gtk-quit"/>
+    <constant name="GTK_STOCK_REDO" type="utf8" type-name="GTK_STOCK_REDO" value="gtk-redo"/>
+    <constant name="GTK_STOCK_REFRESH" type="utf8" type-name="GTK_STOCK_REFRESH" value="gtk-refresh"/>
+    <constant name="GTK_STOCK_REMOVE" type="utf8" type-name="GTK_STOCK_REMOVE" value="gtk-remove"/>
+    <constant name="GTK_STOCK_REVERT_TO_SAVED" type="utf8" type-name="GTK_STOCK_REVERT_TO_SAVED" value="gtk-revert-to-saved"/>
+    <constant name="GTK_STOCK_SAVE" type="utf8" type-name="GTK_STOCK_SAVE" value="gtk-save"/>
+    <constant name="GTK_STOCK_SAVE_AS" type="utf8" type-name="GTK_STOCK_SAVE_AS" value="gtk-save-as"/>
+    <constant name="GTK_STOCK_SELECT_ALL" type="utf8" type-name="GTK_STOCK_SELECT_ALL" value="gtk-select-all"/>
+    <constant name="GTK_STOCK_SELECT_COLOR" type="utf8" type-name="GTK_STOCK_SELECT_COLOR" value="gtk-select-color"/>
+    <constant name="GTK_STOCK_SELECT_FONT" type="utf8" type-name="GTK_STOCK_SELECT_FONT" value="gtk-select-font"/>
+    <constant name="GTK_STOCK_SORT_ASCENDING" type="utf8" type-name="GTK_STOCK_SORT_ASCENDING" value="gtk-sort-ascending"/>
+    <constant name="GTK_STOCK_SORT_DESCENDING" type="utf8" type-name="GTK_STOCK_SORT_DESCENDING" value="gtk-sort-descending"/>
+    <constant name="GTK_STOCK_SPELL_CHECK" type="utf8" type-name="GTK_STOCK_SPELL_CHECK" value="gtk-spell-check"/>
+    <constant name="GTK_STOCK_STOP" type="utf8" type-name="GTK_STOCK_STOP" value="gtk-stop"/>
+    <constant name="GTK_STOCK_STRIKETHROUGH" type="utf8" type-name="GTK_STOCK_STRIKETHROUGH" value="gtk-strikethrough"/>
+    <constant name="GTK_STOCK_UNDELETE" type="utf8" type-name="GTK_STOCK_UNDELETE" value="gtk-undelete"/>
+    <constant name="GTK_STOCK_UNDERLINE" type="utf8" type-name="GTK_STOCK_UNDERLINE" value="gtk-underline"/>
+    <constant name="GTK_STOCK_UNDO" type="utf8" type-name="GTK_STOCK_UNDO" value="gtk-undo"/>
+    <constant name="GTK_STOCK_UNINDENT" type="utf8" type-name="GTK_STOCK_UNINDENT" value="gtk-unindent"/>
+    <constant name="GTK_STOCK_YES" type="utf8" type-name="GTK_STOCK_YES" value="gtk-yes"/>
+    <constant name="GTK_STOCK_ZOOM_100" type="utf8" type-name="GTK_STOCK_ZOOM_100" value="gtk-zoom-100"/>
+    <constant name="GTK_STOCK_ZOOM_FIT" type="utf8" type-name="GTK_STOCK_ZOOM_FIT" value="gtk-zoom-fit"/>
+    <constant name="GTK_STOCK_ZOOM_IN" type="utf8" type-name="GTK_STOCK_ZOOM_IN" value="gtk-zoom-in"/>
+    <constant name="GTK_STOCK_ZOOM_OUT" type="utf8" type-name="GTK_STOCK_ZOOM_OUT" value="gtk-zoom-out"/>
+  </namespace>
+</api>

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0.metadata b/vapigen/packages/gtk+-2.0/gtk+-2.0.metadata
new file mode 100644 (file)
index 0000000..be96f0a
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0.metadata
@@ -0,0 +1,68 @@
+Gtk cheader_filename="gtk/gtk.h"
+GtkAction::activate has_emitter="1"
+GtkAdjustment::changed has_emitter="1"
+GtkAdjustment::value_changed has_emitter="1"
+GtkButton::clicked has_emitter="1"
+GtkButton::enter has_emitter="1"
+GtkButton::leave has_emitter="1"
+GtkButton::pressed has_emitter="1"
+GtkButton::released has_emitter="1"
+GtkCallbackMarshal hidden="1"
+GtkCheckMenuItem::toggled has_emitter="1"
+GtkContainer::add has_emitter="1"
+GtkContainer::check_resize has_emitter="1"
+GtkContainer::remove has_emitter="1"
+GtkContainer::set_focus_child has_emitter="1"
+GtkDialog::response has_emitter="1"
+GtkEntryCompletion::insert_prefix has_emitter="1"
+GtkIconView::item_activated has_emitter="1"
+gtk_icon_view_select_all hidden="1" experimental="1"
+gtk_icon_view_unselect_all hidden="1" experimental="1"
+GtkIMContext::delete_surrounding has_emitter="1"
+GtkItem::deselect has_emitter="1"
+GtkItem::select has_emitter="1"
+GtkItem::toggle has_emitter="1"
+GtkMenuItem::activate has_emitter="1"
+GtkMenuItem::toggle_size_allocate has_emitter="1"
+GtkMenuItem::toggle_size_request has_emitter="1"
+GtkMenuShell::cancel has_emitter="1"
+GtkMenuShell::deactivate has_emitter="1"
+gtk_object_destroy hidden="1" experimental="1"
+gtk_printer_accepts_pdf hidden="1" experimental="1"
+gtk_printer_accepts_ps hidden="1" experimental="1"
+gtk_printer_is_virtual hidden="1" experimental="1"
+gtk_quit_add_full hidden="1"
+GtkTextBuffer::apply_tag has_emitter="1"
+GtkTextBuffer::begin_user_action has_emitter="1"
+GtkTextBuffer::end_user_action has_emitter="1"
+GtkTextBuffer::insert_child_anchor has_emitter="1"
+GtkTextBuffer::insert_pixbuf has_emitter="1"
+GtkTextBuffer::remove_tag has_emitter="1"
+GtkTextTag::event has_emitter="1"
+GtkToggleAction::toggled has_emitter="1"
+GtkToggleButton::toggled has_emitter="1"
+GtkToolItem::set_tooltip has_emitter="1"
+GtkTreeView::row_activated has_emitter="1"
+GtkTreeView::row_expanded has_emitter="1"
+GtkTreeViewColumn::clicked has_emitter="1"
+gtk_tree_view_column_new_with_attributes ellipsis="1"
+GtkWidget::can_activate_accel has_emitter="1"
+gtk_widget_destroy hidden="1"
+GtkWidget::event has_emitter="1"
+gtk_widget_is_focus hidden="1" experimental="1"
+GtkWidget::child_notify has_emitter="1"
+GtkWidget::grab_focus has_emitter="1"
+GtkWidget::hide has_emitter="1"
+GtkWidget::map has_emitter="1"
+GtkWidget::mnemonic_activate has_emitter="1"
+GtkWidget::realize has_emitter="1"
+GtkWidget::size_allocate has_emitter="1"
+GtkWidget::size_request has_emitter="1"
+GtkWidget::show has_emitter="1"
+GtkWidget::unmap has_emitter="1"
+GtkWidget::unrealize has_emitter="1"
+gtk_window_has_toplevel_focus hidden="1" experimental="1"
+gtk_window_is_active hidden="1" experimental="1"
+GtkWindow::activate_default name="default_activated" experimental="1"
+GtkWindow::activate_focus name="focus_activated" experimental="1"
+GtkWindow::set_focus has_emitter="1"

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0.namespace b/vapigen/packages/gtk+-2.0/gtk+-2.0.namespace
new file mode 100644 (file)
index 0000000..0be6e7e
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0.namespace
@@ -0,0 +1 @@
+Gtk

diff --git a/vapigen/packages/gtk+-2.0/gtk+-2.0.patch b/vapigen/packages/gtk+-2.0/gtk+-2.0.patch
new file mode 100644 (file)
index 0000000..454418c
--- /dev/null
+++ b/vapigen/packages/gtk+-2.0/gtk+-2.0.patch
@@ -0,0 +1,24 @@
+diff -puNr gtk+-2.10.1.orig/gtk/gtkclipboard.h gtk+-2.10.1/gtk/gtkclipboard.h
+--- gtk+-2.10.1.orig/gtk/gtkclipboard.h        2006-04-24 07:42:12.000000000 +0200
++++ gtk+-2.10.1/gtk/gtkclipboard.h     2006-08-07 16:32:29.000000000 +0200
+@@ -30,6 +30,9 @@ G_BEGIN_DECLS
+ #define GTK_CLIPBOARD(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CLIPBOARD, GtkClipboard))
+ #define GTK_IS_CLIPBOARD(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CLIPBOARD))
+ 
++typedef struct _GtkClipboard GtkClipboard;
++typedef struct _GtkClipboardClass GtkClipboardClass;
++
+ typedef void (* GtkClipboardReceivedFunc)         (GtkClipboard     *clipboard,
+                                                  GtkSelectionData *selection_data,
+                                                  gpointer          data);
+diff -puNr gtk+-2.10.1.orig/gtk/gtkfilechooser.h gtk+-2.10.1/gtk/gtkfilechooser.h
+--- gtk+-2.10.1.orig/gtk/gtkfilechooser.h      2005-10-10 16:29:03.000000000 +0200
++++ gtk+-2.10.1/gtk/gtkfilechooser.h   2006-08-07 16:34:13.000000000 +0200
+@@ -29,6 +29,7 @@ G_BEGIN_DECLS
+ #define GTK_TYPE_FILE_CHOOSER             (gtk_file_chooser_get_type ())
+ #define GTK_FILE_CHOOSER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER, GtkFileChooser))
+ #define GTK_IS_FILE_CHOOSER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER))
++#define GTK_FILE_CHOOSER_GET_IFACE(obj)   (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_FILE_CHOOSER, GtkFileChooserIface))
+ 
+ typedef struct _GtkFileChooser      GtkFileChooser;
+ 

diff --git a/vapigen/packages/pango/pango.excludes b/vapigen/packages/pango/pango.excludes
new file mode 100644 (file)
index 0000000..c7636e1
--- /dev/null
+++ b/vapigen/packages/pango/pango.excludes
@@ -0,0 +1,35 @@
+pangocairo.h
+pangocairo-atsui.h
+pangocairo-atsuifont.h
+pangocairo-fc.h
+pangocairo-win32.h
+pangocairo-private.h
+pangofc-decoder.c
+pangofc-decoder.h
+pangofc-font.c
+pangofc-font.h
+pangofc-fontmap.c
+pangofc-fontmap.h
+pangofc-private.h
+pangoft2.c
+pangoft2.h
+pangoft2-fontmap.c
+pangoft2-private.h
+pangoft2-render.c
+pangox-fontcache.c
+pangox-fontmap.c
+pangox-private.h
+pangox.h
+pangox.c
+pangoxft.h
+pangoxft-font.c
+pangoxft-font.h
+pangoxft-fontmap.c
+pangoxft-fontmap.h
+pangoxft-private.h
+pangoxft-render.c
+pangoxft-render.h
+pango-color-table.h
+pango-impl-utils.h
+pango-script-lang-table.h
+pango-script-table.h

diff --git a/vapigen/packages/pango/pango.files b/vapigen/packages/pango/pango.files
new file mode 100644 (file)
index 0000000..98ccac5
--- /dev/null
+++ b/vapigen/packages/pango/pango.files
@@ -0,0 +1 @@
+pango

diff --git a/vapigen/packages/pango/pango.gidl b/vapigen/packages/pango/pango.gidl
new file mode 100644 (file)
index 0000000..8c84c8e
--- /dev/null
+++ b/vapigen/packages/pango/pango.gidl
@@ -0,0 +1,2474 @@
+<?xml version="1.0"?>
+<api version="1.0">
+  <!--
+
+        This file was automatically generated.
+        Please DO NOT MODIFY THIS FILE, modify .metadata files instead.
+
+-->
+  <namespace name="Pango">
+    <enum get-type="pango_alignment_get_type" name="PangoAlignment" type="enum" type-name="PangoAlignment">
+      <member name="PANGO_ALIGN_LEFT" value=""/>
+      <member name="PANGO_ALIGN_CENTER" value=""/>
+      <member name="PANGO_ALIGN_RIGHT" value=""/>
+    </enum>
+    <enum get-type="pango_attr_type_get_type" name="PangoAttrType" type="enum" type-name="PangoAttrType">
+      <member name="PANGO_ATTR_INVALID" value=""/>
+      <member name="PANGO_ATTR_LANGUAGE" value=""/>
+      <member name="PANGO_ATTR_FAMILY" value=""/>
+      <member name="PANGO_ATTR_STYLE" value=""/>
+      <member name="PANGO_ATTR_WEIGHT" value=""/>
+      <member name="PANGO_ATTR_VARIANT" value=""/>
+      <member name="PANGO_ATTR_STRETCH" value=""/>
+      <member name="PANGO_ATTR_SIZE" value=""/>
+      <member name="PANGO_ATTR_FONT_DESC" value=""/>
+      <member name="PANGO_ATTR_FOREGROUND" value=""/>
+      <member name="PANGO_ATTR_BACKGROUND" value=""/>
+      <member name="PANGO_ATTR_UNDERLINE" value=""/>
+      <member name="PANGO_ATTR_STRIKETHROUGH" value=""/>
+      <member name="PANGO_ATTR_RISE" value=""/>
+      <member name="PANGO_ATTR_SHAPE" value=""/>
+      <member name="PANGO_ATTR_SCALE" value=""/>
+      <member name="PANGO_ATTR_FALLBACK" value=""/>
+      <member name="PANGO_ATTR_LETTER_SPACING" value=""/>
+      <member name="PANGO_ATTR_UNDERLINE_COLOR" value=""/>
+      <member name="PANGO_ATTR_STRIKETHROUGH_COLOR" value=""/>
+      <member name="PANGO_ATTR_ABSOLUTE_SIZE" value=""/>
+    </enum>
+    <enum get-type="pango_coverage_level_get_type" name="PangoCoverageLevel" type="enum" type-name="PangoCoverageLevel">
+      <member name="PANGO_COVERAGE_NONE" value=""/>
+      <member name="PANGO_COVERAGE_FALLBACK" value=""/>
+      <member name="PANGO_COVERAGE_APPROXIMATE" value=""/>
+      <member name="PANGO_COVERAGE_EXACT" value=""/>
+    </enum>
+    <enum get-type="pango_direction_get_type" name="PangoDirection" type="enum" type-name="PangoDirection">
+      <member name="PANGO_DIRECTION_LTR" value=""/>
+      <member name="PANGO_DIRECTION_RTL" value=""/>
+      <member name="PANGO_DIRECTION_TTB_LTR" value=""/>
+      <member name="PANGO_DIRECTION_TTB_RTL" value=""/>
+      <member name="PANGO_DIRECTION_WEAK_LTR" value=""/>
+      <member name="PANGO_DIRECTION_WEAK_RTL" value=""/>
+      <member name="PANGO_DIRECTION_NEUTRAL" value=""/>
+    </enum>
+    <enum get-type="pango_ellipsize_mode_get_type" name="PangoEllipsizeMode" type="enum" type-name="PangoEllipsizeMode">
+      <member name="PANGO_ELLIPSIZE_NONE" value=""/>
+      <member name="PANGO_ELLIPSIZE_START" value=""/>
+      <member name="PANGO_ELLIPSIZE_MIDDLE" value=""/>
+      <member name="PANGO_ELLIPSIZE_END" value=""/>
+    </enum>
+    <enum get-type="pango_font_mask_get_type" name="PangoFontMask" type="flags" type-name="PangoFontMask">
+      <member name="PANGO_FONT_MASK_FAMILY" value=""/>
+      <member name="PANGO_FONT_MASK_STYLE" value=""/>
+      <member name="PANGO_FONT_MASK_VARIANT" value=""/>
+      <member name="PANGO_FONT_MASK_WEIGHT" value=""/>
+      <member name="PANGO_FONT_MASK_STRETCH" value=""/>
+      <member name="PANGO_FONT_MASK_SIZE" value=""/>
+    </enum>
+    <enum get-type="pango_render_part_get_type" name="PangoRenderPart" type="enum" type-name="PangoRenderPart">
+      <member name="PANGO_RENDER_PART_FOREGROUND" value=""/>
+      <member name="PANGO_RENDER_PART_BACKGROUND" value=""/>
+      <member name="PANGO_RENDER_PART_UNDERLINE" value=""/>
+      <member name="PANGO_RENDER_PART_STRIKETHROUGH" value=""/>
+    </enum>
+    <enum get-type="pango_script_get_type" name="PangoScript" type="enum" type-name="PangoScript">
+      <member name="PANGO_SCRIPT_INVALID_CODE" value="-1"/>
+      <member name="PANGO_SCRIPT_COMMON" value="0"/>
+      <member name="PANGO_SCRIPT_INHERITED" value=""/>
+      <member name="PANGO_SCRIPT_ARABIC" value=""/>
+      <member name="PANGO_SCRIPT_ARMENIAN" value=""/>
+      <member name="PANGO_SCRIPT_BENGALI" value=""/>
+      <member name="PANGO_SCRIPT_BOPOMOFO" value=""/>
+      <member name="PANGO_SCRIPT_CHEROKEE" value=""/>
+      <member name="PANGO_SCRIPT_COPTIC" value=""/>
+      <member name="PANGO_SCRIPT_CYRILLIC" value=""/>
+      <member name="PANGO_SCRIPT_DESERET" value=""/>
+      <member name="PANGO_SCRIPT_DEVANAGARI" value=""/>
+      <member name="PANGO_SCRIPT_ETHIOPIC" value=""/>
+      <member name="PANGO_SCRIPT_GEORGIAN" value=""/>
+      <member name="PANGO_SCRIPT_GOTHIC" value=""/>
+      <member name="PANGO_SCRIPT_GREEK" value=""/>
+      <member name="PANGO_SCRIPT_GUJARATI" value=""/>
+      <member name="PANGO_SCRIPT_GURMUKHI" value=""/>
+      <member name="PANGO_SCRIPT_HAN" value=""/>
+      <member name="PANGO_SCRIPT_HANGUL" value=""/>
+      <member name="PANGO_SCRIPT_HEBREW" value=""/>
+      <member name="PANGO_SCRIPT_HIRAGANA" value=""/>
+      <member name="PANGO_SCRIPT_KANNADA" value=""/>
+      <member name="PANGO_SCRIPT_KATAKANA" value=""/>
+      <member name="PANGO_SCRIPT_KHMER" value=""/>
+      <member name="PANGO_SCRIPT_LAO" value=""/>
+      <member name="PANGO_SCRIPT_LATIN" value=""/>
+      <member name="PANGO_SCRIPT_MALAYALAM" value=""/>
+      <member name="PANGO_SCRIPT_MONGOLIAN" value=""/>
+      <member name="PANGO_SCRIPT_MYANMAR" value=""/>
+      <member name="PANGO_SCRIPT_OGHAM" value=""/>
+      <member name="PANGO_SCRIPT_OLD_ITALIC" value=""/>
+      <member name="PANGO_SCRIPT_ORIYA" value=""/>
+      <member name="PANGO_SCRIPT_RUNIC" value=""/>
+      <member name="PANGO_SCRIPT_SINHALA" value=""/>
+      <member name="PANGO_SCRIPT_SYRIAC" value=""/>
+      <member name="PANGO_SCRIPT_TAMIL" value=""/>
+      <member name="PANGO_SCRIPT_TELUGU" value=""/>
+      <member name="PANGO_SCRIPT_THAANA" value=""/>
+      <member name="PANGO_SCRIPT_THAI" value=""/>
+      <member name="PANGO_SCRIPT_TIBETAN" value=""/>
+      <member name="PANGO_SCRIPT_CANADIAN_ABORIGINAL" value=""/>
+      <member name="PANGO_SCRIPT_YI" value=""/>
+      <member name="PANGO_SCRIPT_TAGALOG" value=""/>
+      <member name="PANGO_SCRIPT_HANUNOO" value=""/>
+      <member name="PANGO_SCRIPT_BUHID" value=""/>
+      <member name="PANGO_SCRIPT_TAGBANWA" value=""/>
+      <member name="PANGO_SCRIPT_BRAILLE" value=""/>
+      <member name="PANGO_SCRIPT_CYPRIOT" value=""/>
+      <member name="PANGO_SCRIPT_LIMBU" value=""/>
+      <member name="PANGO_SCRIPT_OSMANYA" value=""/>
+      <member name="PANGO_SCRIPT_SHAVIAN" value=""/>
+      <member name="PANGO_SCRIPT_LINEAR_B" value=""/>
+      <member name="PANGO_SCRIPT_TAI_LE" value=""/>
+      <member name="PANGO_SCRIPT_UGARITIC" value=""/>
+      <member name="PANGO_SCRIPT_NEW_TAI_LUE" value=""/>
+      <member name="PANGO_SCRIPT_BUGINESE" value=""/>
+      <member name="PANGO_SCRIPT_GLAGOLITIC" value=""/>
+      <member name="PANGO_SCRIPT_TIFINAGH" value=""/>
+      <member name="PANGO_SCRIPT_SYLOTI_NAGRI" value=""/>
+      <member name="PANGO_SCRIPT_OLD_PERSIAN" value=""/>
+      <member name="PANGO_SCRIPT_KHAROSHTHI" value=""/>
+      <member name="PANGO_SCRIPT_UNKNOWN" value=""/>
+      <member name="PANGO_SCRIPT_BALINESE" value=""/>
+      <member name="PANGO_SCRIPT_CUNEIFORM" value=""/>
+      <member name="PANGO_SCRIPT_PHOENICIAN" value=""/>
+      <member name="PANGO_SCRIPT_PHAGS_PA" value=""/>
+      <member name="PANGO_SCRIPT_NKO" value=""/>
+    </enum>
+    <enum get-type="pango_stretch_get_type" name="PangoStretch" type="enum" type-name="PangoStretch">
+      <member name="PANGO_STRETCH_ULTRA_CONDENSED" value=""/>
+      <member name="PANGO_STRETCH_EXTRA_CONDENSED" value=""/>
+      <member name="PANGO_STRETCH_CONDENSED" value=""/>
+      <member name="PANGO_STRETCH_SEMI_CONDENSED" value=""/>
+      <member name="PANGO_STRETCH_NORMAL" value=""/>
+      <member name="PANGO_STRETCH_SEMI_EXPANDED" value=""/>
+      <member name="PANGO_STRETCH_EXPANDED" value=""/>
+      <member name="PANGO_STRETCH_EXTRA_EXPANDED" value=""/>
+      <member name="PANGO_STRETCH_ULTRA_EXPANDED" value=""/>
+    </enum>
+    <enum get-type="pango_style_get_type" name="PangoStyle" type="enum" type-name="PangoStyle">
+      <member name="PANGO_STYLE_NORMAL" value=""/>
+      <member name="PANGO_STYLE_OBLIQUE" value=""/>
+      <member name="PANGO_STYLE_ITALIC" value=""/>
+    </enum>
+    <enum get-type="pango_tab_align_get_type" name="PangoTabAlign" type="enum" type-name="PangoTabAlign">
+      <member name="PANGO_TAB_LEFT" value=""/>
+    </enum>
+    <enum get-type="pango_underline_get_type" name="PangoUnderline" type="enum" type-name="PangoUnderline">
+      <member name="PANGO_UNDERLINE_NONE" value=""/>
+      <member name="PANGO_UNDERLINE_SINGLE" value=""/>
+      <member name="PANGO_UNDERLINE_DOUBLE" value=""/>
+      <member name="PANGO_UNDERLINE_LOW" value=""/>
+      <member name="PANGO_UNDERLINE_ERROR" value=""/>
+    </enum>
+    <enum get-type="pango_variant_get_type" name="PangoVariant" type="enum" type-name="PangoVariant">
+      <member name="PANGO_VARIANT_NORMAL" value=""/>
+      <member name="PANGO_VARIANT_SMALL_CAPS" value=""/>
+    </enum>
+    <enum get-type="pango_weight_get_type" name="PangoWeight" type="enum" type-name="PangoWeight">
+      <member name="PANGO_WEIGHT_ULTRALIGHT" value="200"/>
+      <member name="PANGO_WEIGHT_LIGHT" value="300"/>
+      <member name="PANGO_WEIGHT_NORMAL" value="400"/>
+      <member name="PANGO_WEIGHT_SEMIBOLD" value="600"/>
+      <member name="PANGO_WEIGHT_BOLD" value="700"/>
+      <member name="PANGO_WEIGHT_ULTRABOLD" value="800"/>
+      <member name="PANGO_WEIGHT_HEAVY" value="900"/>
+    </enum>
+    <enum get-type="pango_wrap_mode_get_type" name="PangoWrapMode" type="enum" type-name="PangoWrapMode">
+      <member name="PANGO_WRAP_WORD" value=""/>
+      <member name="PANGO_WRAP_CHAR" value=""/>
+      <member name="PANGO_WRAP_WORD_CHAR" value=""/>
+    </enum>
+    <callback name="PangoAttrDataCopyFunc" type-name="PangoAttrDataCopyFunc">
+      <return-type type="gpointer"/>
+      <parameters>
+        <parameter name="data" type="gconstpointer"/>
+      </parameters>
+    </callback>
+    <callback name="PangoAttrFilterFunc" type-name="PangoAttrFilterFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="attribute" type="PangoAttribute*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <callback name="PangoFontsetForeachFunc" type-name="PangoFontsetForeachFunc">
+      <return-type type="gboolean"/>
+      <parameters>
+        <parameter name="fontset" type="PangoFontset*"/>
+        <parameter name="font" type="PangoFont*"/>
+        <parameter name="data" type="gpointer"/>
+      </parameters>
+    </callback>
+    <object get-type="" name="PangoContext" parent="GObject" type-name="PangoContext">
+      <method name="get_base_dir" symbol="pango_context_get_base_dir">
+        <return-type type="PangoDirection"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+        </parameters>
+      </method>
+      <method name="get_font_description" symbol="pango_context_get_font_description">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+        </parameters>
+      </method>
+      <method name="get_font_map" symbol="pango_context_get_font_map">
+        <return-type type="PangoFontMap*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+        </parameters>
+      </method>
+      <method name="get_language" symbol="pango_context_get_language">
+        <return-type type="PangoLanguage*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+        </parameters>
+      </method>
+      <method name="get_matrix" symbol="pango_context_get_matrix">
+        <return-type type="const-PangoMatrix*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+        </parameters>
+      </method>
+      <method name="get_metrics" symbol="pango_context_get_metrics">
+        <return-type type="PangoFontMetrics*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_context_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="list_families" symbol="pango_context_list_families">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="families" type="PangoFontFamily***"/>
+          <parameter name="n_families" type="int*"/>
+        </parameters>
+      </method>
+      <method name="load_font" symbol="pango_context_load_font">
+        <return-type type="PangoFont*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="load_fontset" symbol="pango_context_load_fontset">
+        <return-type type="PangoFontset*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+      <method name="set_base_dir" symbol="pango_context_set_base_dir">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="direction" type="PangoDirection"/>
+        </parameters>
+      </method>
+      <method name="set_font_description" symbol="pango_context_set_font_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="set_language" symbol="pango_context_set_language">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+      <method name="set_matrix" symbol="pango_context_set_matrix">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="matrix" type="const-PangoMatrix*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="PangoFont" parent="GObject" type-name="PangoFont">
+      <method name="describe" symbol="pango_font_describe">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+        </parameters>
+      </method>
+      <method name="describe_with_absolute_size" symbol="pango_font_describe_with_absolute_size">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+        </parameters>
+      </method>
+      <method name="descriptions_free" symbol="pango_font_descriptions_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="descs" type="PangoFontDescription**"/>
+          <parameter name="n_descs" type="int"/>
+        </parameters>
+      </method>
+      <method name="find_shaper" symbol="pango_font_find_shaper">
+        <return-type type="PangoEngineShape*"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+          <parameter name="ch" type="guint32"/>
+        </parameters>
+      </method>
+      <method name="get_coverage" symbol="pango_font_get_coverage">
+        <return-type type="PangoCoverage*"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+      <method name="get_font_map" symbol="pango_font_get_font_map">
+        <return-type type="PangoFontMap*"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+        </parameters>
+      </method>
+      <method name="get_glyph_extents" symbol="pango_font_get_glyph_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="glyph" type="PangoGlyph"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_metrics" symbol="pango_font_get_metrics">
+        <return-type type="PangoFontMetrics*"/>
+        <parameters>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_font_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="PangoFontset" parent="GObject" type-name="PangoFontset">
+      <method name="foreach" symbol="pango_fontset_foreach">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fontset" type="PangoFontset*"/>
+          <parameter name="func" type="PangoFontsetForeachFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="get_font" symbol="pango_fontset_get_font">
+        <return-type type="PangoFont*"/>
+        <parameters>
+          <parameter name="fontset" type="PangoFontset*"/>
+          <parameter name="wc" type="guint"/>
+        </parameters>
+      </method>
+      <method name="get_metrics" symbol="pango_fontset_get_metrics">
+        <return-type type="PangoFontMetrics*"/>
+        <parameters>
+          <parameter name="fontset" type="PangoFontset*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_fontset_get_type">
+        <return-type type="GType"/>
+      </method>
+    </object>
+    <object get-type="" name="PangoFontFace" parent="GObject" type-name="PangoFontFace">
+      <method name="describe" symbol="pango_font_face_describe">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="face" type="PangoFontFace*"/>
+        </parameters>
+      </method>
+      <method name="get_face_name" symbol="pango_font_face_get_face_name">
+        <return-type type="const-char*"/>
+        <parameters>
+          <parameter name="face" type="PangoFontFace*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_font_face_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="list_sizes" symbol="pango_font_face_list_sizes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="face" type="PangoFontFace*"/>
+          <parameter name="sizes" type="int**"/>
+          <parameter name="n_sizes" type="int*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="PangoFontFamily" parent="GObject" type-name="PangoFontFamily">
+      <method name="get_name" symbol="pango_font_family_get_name">
+        <return-type type="const-char*"/>
+        <parameters>
+          <parameter name="family" type="PangoFontFamily*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_font_family_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="is_monospace" symbol="pango_font_family_is_monospace">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="family" type="PangoFontFamily*"/>
+        </parameters>
+      </method>
+      <method name="list_faces" symbol="pango_font_family_list_faces">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="family" type="PangoFontFamily*"/>
+          <parameter name="faces" type="PangoFontFace***"/>
+          <parameter name="n_faces" type="int*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="PangoFontMap" parent="GObject" type-name="PangoFontMap">
+      <method name="get_type" symbol="pango_font_map_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="list_families" symbol="pango_font_map_list_families">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="fontmap" type="PangoFontMap*"/>
+          <parameter name="families" type="PangoFontFamily***"/>
+          <parameter name="n_families" type="int*"/>
+        </parameters>
+      </method>
+      <method name="load_font" symbol="pango_font_map_load_font">
+        <return-type type="PangoFont*"/>
+        <parameters>
+          <parameter name="fontmap" type="PangoFontMap*"/>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="load_fontset" symbol="pango_font_map_load_fontset">
+        <return-type type="PangoFontset*"/>
+        <parameters>
+          <parameter name="fontmap" type="PangoFontMap*"/>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="PangoLayout" parent="GObject" type-name="PangoLayout">
+      <method name="context_changed" symbol="pango_layout_context_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="pango_layout_copy">
+        <return-type type="PangoLayout*"/>
+        <parameters>
+          <parameter name="src" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_alignment" symbol="pango_layout_get_alignment">
+        <return-type type="PangoAlignment"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_attributes" symbol="pango_layout_get_attributes">
+        <return-type type="PangoAttrList*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_auto_dir" symbol="pango_layout_get_auto_dir">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_context" symbol="pango_layout_get_context">
+        <return-type type="PangoContext*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_cursor_pos" symbol="pango_layout_get_cursor_pos">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="index_" type="int"/>
+          <parameter name="strong_pos" type="PangoRectangle*"/>
+          <parameter name="weak_pos" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_ellipsize" symbol="pango_layout_get_ellipsize">
+        <return-type type="PangoEllipsizeMode"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_extents" symbol="pango_layout_get_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_font_description" symbol="pango_layout_get_font_description">
+        <return-type type="const-PangoFontDescription*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_indent" symbol="pango_layout_get_indent">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_iter" symbol="pango_layout_get_iter">
+        <return-type type="PangoLayoutIter*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_justify" symbol="pango_layout_get_justify">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_line" symbol="pango_layout_get_line">
+        <return-type type="PangoLayoutLine*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="line" type="int"/>
+        </parameters>
+      </method>
+      <method name="get_line_count" symbol="pango_layout_get_line_count">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_lines" symbol="pango_layout_get_lines">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_log_attrs" symbol="pango_layout_get_log_attrs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="attrs" type="PangoLogAttr**"/>
+          <parameter name="n_attrs" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_pixel_extents" symbol="pango_layout_get_pixel_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_pixel_size" symbol="pango_layout_get_pixel_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="width" type="int*"/>
+          <parameter name="height" type="int*"/>
+        </parameters>
+      </method>
+      <method name="get_single_paragraph_mode" symbol="pango_layout_get_single_paragraph_mode">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="pango_layout_get_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="width" type="int*"/>
+          <parameter name="height" type="int*"/>
+        </parameters>
+      </method>
+      <method name="get_spacing" symbol="pango_layout_get_spacing">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_tabs" symbol="pango_layout_get_tabs">
+        <return-type type="PangoTabArray*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_text" symbol="pango_layout_get_text">
+        <return-type type="const-char*"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_layout_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="pango_layout_get_width">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="get_wrap" symbol="pango_layout_get_wrap">
+        <return-type type="PangoWrapMode"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+        </parameters>
+      </method>
+      <method name="index_to_line_x" symbol="pango_layout_index_to_line_x">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="index_" type="int"/>
+          <parameter name="trailing" type="gboolean"/>
+          <parameter name="line" type="int*"/>
+          <parameter name="x_pos" type="int*"/>
+        </parameters>
+      </method>
+      <method name="index_to_pos" symbol="pango_layout_index_to_pos">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="index_" type="int"/>
+          <parameter name="pos" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="move_cursor_visually" symbol="pango_layout_move_cursor_visually">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="strong" type="gboolean"/>
+          <parameter name="old_index" type="int"/>
+          <parameter name="old_trailing" type="int"/>
+          <parameter name="direction" type="int"/>
+          <parameter name="new_index" type="int*"/>
+          <parameter name="new_trailing" type="int*"/>
+        </parameters>
+      </method>
+      <constructor name="new" symbol="pango_layout_new">
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+        </parameters>
+      </constructor>
+      <method name="set_alignment" symbol="pango_layout_set_alignment">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="alignment" type="PangoAlignment"/>
+        </parameters>
+      </method>
+      <method name="set_attributes" symbol="pango_layout_set_attributes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="attrs" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+      <method name="set_auto_dir" symbol="pango_layout_set_auto_dir">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="auto_dir" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_ellipsize" symbol="pango_layout_set_ellipsize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="ellipsize" type="PangoEllipsizeMode"/>
+        </parameters>
+      </method>
+      <method name="set_font_description" symbol="pango_layout_set_font_description">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="set_indent" symbol="pango_layout_set_indent">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="indent" type="int"/>
+        </parameters>
+      </method>
+      <method name="set_justify" symbol="pango_layout_set_justify">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="justify" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_markup" symbol="pango_layout_set_markup">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="markup" type="const-char*"/>
+          <parameter name="length" type="int"/>
+        </parameters>
+      </method>
+      <method name="set_markup_with_accel" symbol="pango_layout_set_markup_with_accel">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="markup" type="const-char*"/>
+          <parameter name="length" type="int"/>
+          <parameter name="accel_marker" type="gunichar"/>
+          <parameter name="accel_char" type="gunichar*"/>
+        </parameters>
+      </method>
+      <method name="set_single_paragraph_mode" symbol="pango_layout_set_single_paragraph_mode">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="setting" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="set_spacing" symbol="pango_layout_set_spacing">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="spacing" type="int"/>
+        </parameters>
+      </method>
+      <method name="set_tabs" symbol="pango_layout_set_tabs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="tabs" type="PangoTabArray*"/>
+        </parameters>
+      </method>
+      <method name="set_text" symbol="pango_layout_set_text">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="length" type="int"/>
+        </parameters>
+      </method>
+      <method name="set_width" symbol="pango_layout_set_width">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="width" type="int"/>
+        </parameters>
+      </method>
+      <method name="set_wrap" symbol="pango_layout_set_wrap">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="wrap" type="PangoWrapMode"/>
+        </parameters>
+      </method>
+      <method name="xy_to_index" symbol="pango_layout_xy_to_index">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+          <parameter name="index_" type="int*"/>
+          <parameter name="trailing" type="int*"/>
+        </parameters>
+      </method>
+    </object>
+    <object get-type="" name="PangoRenderer" parent="GObject" type-name="PangoRenderer">
+      <field name="underline" type="PangoUnderline"/>
+      <field name="strikethrough" type="gboolean"/>
+      <field name="active_count" type="int"/>
+      <field name="matrix" readable="1" type="PangoMatrix*" writable="1"/>
+      <field name="priv" type="PangoRendererPrivate*"/>
+      <vfunc name="draw_glyphs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_rectangle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_error_underline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_shape">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="attr" type="PangoAttrShape*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_trapezoid">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="y1_" type="double"/>
+          <parameter name="x11" type="double"/>
+          <parameter name="x21" type="double"/>
+          <parameter name="y2" type="double"/>
+          <parameter name="x12" type="double"/>
+          <parameter name="x22" type="double"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="draw_glyph">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="glyph" type="PangoGlyph"/>
+          <parameter name="x" type="double"/>
+          <parameter name="y" type="double"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="part_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="begin">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="end">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+        </parameters>
+      </vfunc>
+      <vfunc name="prepare_run">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="run" type="PangoLayoutRun*"/>
+        </parameters>
+      </vfunc>
+      <method name="activate" symbol="pango_renderer_activate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+        </parameters>
+      </method>
+      <method name="deactivate" symbol="pango_renderer_deactivate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+        </parameters>
+      </method>
+      <method name="draw_error_underline" symbol="pango_renderer_draw_error_underline">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </method>
+      <method name="draw_glyph" symbol="pango_renderer_draw_glyph">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="glyph" type="PangoGlyph"/>
+          <parameter name="x" type="double"/>
+          <parameter name="y" type="double"/>
+        </parameters>
+      </method>
+      <method name="draw_glyphs" symbol="pango_renderer_draw_glyphs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+        </parameters>
+      </method>
+      <method name="draw_layout" symbol="pango_renderer_draw_layout">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="layout" type="PangoLayout*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+        </parameters>
+      </method>
+      <method name="draw_layout_line" symbol="pango_renderer_draw_layout_line">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+        </parameters>
+      </method>
+      <method name="draw_rectangle" symbol="pango_renderer_draw_rectangle">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="x" type="int"/>
+          <parameter name="y" type="int"/>
+          <parameter name="width" type="int"/>
+          <parameter name="height" type="int"/>
+        </parameters>
+      </method>
+      <method name="draw_trapezoid" symbol="pango_renderer_draw_trapezoid">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="y1_" type="double"/>
+          <parameter name="x11" type="double"/>
+          <parameter name="x21" type="double"/>
+          <parameter name="y2" type="double"/>
+          <parameter name="x12" type="double"/>
+          <parameter name="x22" type="double"/>
+        </parameters>
+      </method>
+      <method name="get_color" symbol="pango_renderer_get_color">
+        <return-type type="PangoColor*"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+        </parameters>
+      </method>
+      <method name="get_matrix" symbol="pango_renderer_get_matrix">
+        <return-type type="const-PangoMatrix*"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_renderer_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="part_changed" symbol="pango_renderer_part_changed">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+        </parameters>
+      </method>
+      <method name="set_color" symbol="pango_renderer_set_color">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="part" type="PangoRenderPart"/>
+          <parameter name="color" type="const-PangoColor*"/>
+        </parameters>
+      </method>
+      <method name="set_matrix" symbol="pango_renderer_set_matrix">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="renderer" type="PangoRenderer*"/>
+          <parameter name="matrix" type="const-PangoMatrix*"/>
+        </parameters>
+      </method>
+    </object>
+    <struct get-type="" name="PangoAnalysis" type-name="PangoAnalysis">
+      <field name="shape_engine" readable="1" type="PangoEngineShape*" writable="1"/>
+      <field name="lang_engine" readable="1" type="PangoEngineLang*" writable="1"/>
+      <field name="font" readable="1" type="PangoFont*" writable="1"/>
+      <field name="level" readable="1" type="guint8" writable="1"/>
+      <field name="language" readable="1" type="PangoLanguage*" writable="1"/>
+      <field name="extra_attrs" readable="1" type="GSList*" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoAttrClass" type-name="PangoAttrClass">
+      <field name="type" readable="1" type="PangoAttrType" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoAttrColor" type-name="PangoAttrColor">
+      <field name="attr" readable="1" type="PangoAttribute" writable="1"/>
+      <field name="color" readable="1" type="PangoColor" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoAttrFloat" type-name="PangoAttrFloat">
+      <field name="attr" readable="1" type="PangoAttribute" writable="1"/>
+      <field name="value" readable="1" type="double" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoAttrFontDesc" opaque="true" type-name="PangoAttrFontDesc">
+      <field access="public" name="attr" readable="1" type="PangoAttribute" writable="1" writeable="true"/>
+      <field access="public" name="desc" readable="1" type="PangoFontDescription*" writable="1" writeable="true"/>
+      <method name="new" symbol="pango_attr_font_desc_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="PangoAttrInt" type-name="PangoAttrInt">
+      <field name="attr" readable="1" type="PangoAttribute" writable="1"/>
+      <field name="value" readable="1" type="int" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoAttrIterator" opaque="true" type-name="PangoAttrIterator">
+      <method name="copy" symbol="pango_attr_iterator_copy">
+        <return-type type="PangoAttrIterator*"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="pango_attr_iterator_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="pango_attr_iterator_get">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+          <parameter name="type" type="PangoAttrType"/>
+        </parameters>
+      </method>
+      <method name="get_attrs" symbol="pango_attr_iterator_get_attrs">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+        </parameters>
+      </method>
+      <method name="get_font" symbol="pango_attr_iterator_get_font">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="language" type="PangoLanguage**"/>
+          <parameter name="extra_attrs" type="GSList**"/>
+        </parameters>
+      </method>
+      <method name="next" symbol="pango_attr_iterator_next">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+        </parameters>
+      </method>
+      <method name="range" symbol="pango_attr_iterator_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iterator" type="PangoAttrIterator*"/>
+          <parameter name="start" type="gint*"/>
+          <parameter name="end" type="gint*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="PangoAttrLanguage" opaque="true" type-name="PangoAttrLanguage">
+      <field access="public" name="attr" readable="1" type="PangoAttribute" writable="1" writeable="true"/>
+      <field access="public" name="value" readable="1" type="PangoLanguage*" writable="1" writeable="true"/>
+      <method name="new" symbol="pango_attr_language_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+    </struct>
+    <boxed get-type="" name="PangoAttrList" opaque="true" type-name="PangoAttrList">
+      <method name="change" symbol="pango_attr_list_change">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+          <parameter name="attr" type="PangoAttribute*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="pango_attr_list_copy">
+        <return-type type="PangoAttrList*"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+      <method name="filter" symbol="pango_attr_list_filter">
+        <return-type type="PangoAttrList*"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+          <parameter name="func" type="PangoAttrFilterFunc"/>
+          <parameter name="data" type="gpointer"/>
+        </parameters>
+      </method>
+      <method name="get_iterator" symbol="pango_attr_list_get_iterator">
+        <return-type type="PangoAttrIterator*"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_attr_list_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="insert" symbol="pango_attr_list_insert">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+          <parameter name="attr" type="PangoAttribute*"/>
+        </parameters>
+      </method>
+      <method name="insert_before" symbol="pango_attr_list_insert_before">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+          <parameter name="attr" type="PangoAttribute*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="pango_attr_list_new">
+        <return-type type="PangoAttrList*"/>
+      </method>
+      <method name="ref" symbol="pango_attr_list_ref">
+        <return-type type="PangoAttrList*"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+      <method name="splice" symbol="pango_attr_list_splice">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+          <parameter name="other" type="PangoAttrList*"/>
+          <parameter name="pos" type="gint"/>
+          <parameter name="len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="pango_attr_list_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="list" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoAttrShape" opaque="true" type-name="PangoAttrShape">
+      <field access="public" name="attr" readable="1" type="PangoAttribute" writable="1" writeable="true"/>
+      <field access="public" name="ink_rect" readable="1" type="PangoRectangle" writable="1" writeable="true"/>
+      <field access="public" name="logical_rect" readable="1" type="PangoRectangle" writable="1" writeable="true"/>
+      <field access="public" name="data" readable="1" type="gpointer" writable="1" writeable="true"/>
+      <field access="public" name="copy_func" readable="1" type="PangoAttrDataCopyFunc" writable="1" writeable="true"/>
+      <field access="public" name="destroy_func" readable="1" type="GDestroyNotify" writable="1" writeable="true"/>
+      <method name="new" symbol="pango_attr_shape_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="ink_rect" type="const-PangoRectangle*"/>
+          <parameter name="logical_rect" type="const-PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="new_with_data" symbol="pango_attr_shape_new_with_data">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="ink_rect" type="const-PangoRectangle*"/>
+          <parameter name="logical_rect" type="const-PangoRectangle*"/>
+          <parameter name="data" type="gpointer"/>
+          <parameter name="copy_func" type="PangoAttrDataCopyFunc"/>
+          <parameter name="destroy_func" type="GDestroyNotify"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="PangoAttrSize" opaque="true" type-name="PangoAttrSize">
+      <field access="public" name="attr" readable="1" type="PangoAttribute" writable="1" writeable="true"/>
+      <field access="public" name="size" readable="1" type="int" writable="1" writeable="true"/>
+      <field access="public" name="absolute" readable="1" type="guint" writable="1" writeable="true"/>
+      <method name="new" symbol="pango_attr_size_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="size" type="int"/>
+        </parameters>
+      </method>
+      <method name="new_absolute" symbol="pango_attr_size_new_absolute">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="size" type="int"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="PangoAttrString" type-name="PangoAttrString">
+      <field name="attr" readable="1" type="PangoAttribute" writable="1"/>
+      <field name="value" readable="1" type="char*" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoAttribute" opaque="true" type-name="PangoAttribute">
+      <field access="public" name="klass" readable="1" type="const-PangoAttrClass*" writable="1" writeable="true"/>
+      <field access="public" name="start_index" readable="1" type="guint" writable="1" writeable="true"/>
+      <field access="public" name="end_index" readable="1" type="guint" writable="1" writeable="true"/>
+      <method name="copy" symbol="pango_attribute_copy">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="attr" type="const-PangoAttribute*"/>
+        </parameters>
+      </method>
+      <method name="destroy" symbol="pango_attribute_destroy">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="attr" type="PangoAttribute*"/>
+        </parameters>
+      </method>
+      <method name="equal" symbol="pango_attribute_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="attr1" type="const-PangoAttribute*"/>
+          <parameter name="attr2" type="const-PangoAttribute*"/>
+        </parameters>
+      </method>
+    </struct>
+    <boxed get-type="" name="PangoColor" type-name="PangoColor">
+      <field name="red" readable="1" type="guint16" writable="1"/>
+      <field name="green" readable="1" type="guint16" writable="1"/>
+      <field name="blue" readable="1" type="guint16" writable="1"/>
+      <method name="copy" symbol="pango_color_copy">
+        <return-type type="PangoColor*"/>
+        <parameters>
+          <parameter name="src" type="const-PangoColor*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_color_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="color" type="PangoColor*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_color_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="parse" symbol="pango_color_parse">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="color" type="PangoColor*"/>
+          <parameter name="spec" type="const-char*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoCoverage" opaque="true" type-name="PangoCoverage">
+      <method name="copy" symbol="pango_coverage_copy">
+        <return-type type="PangoCoverage*"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+        </parameters>
+      </method>
+      <method name="from_bytes" symbol="pango_coverage_from_bytes">
+        <return-type type="PangoCoverage*"/>
+        <parameters>
+          <parameter name="bytes" type="guchar*"/>
+          <parameter name="n_bytes" type="int"/>
+        </parameters>
+      </method>
+      <method name="get" symbol="pango_coverage_get">
+        <return-type type="PangoCoverageLevel"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+          <parameter name="index_" type="int"/>
+        </parameters>
+      </method>
+      <method name="max" symbol="pango_coverage_max">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+          <parameter name="other" type="PangoCoverage*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="pango_coverage_new">
+        <return-type type="PangoCoverage*"/>
+      </method>
+      <method name="ref" symbol="pango_coverage_ref">
+        <return-type type="PangoCoverage*"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+        </parameters>
+      </method>
+      <method name="set" symbol="pango_coverage_set">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+          <parameter name="index_" type="int"/>
+          <parameter name="level" type="PangoCoverageLevel"/>
+        </parameters>
+      </method>
+      <method name="to_bytes" symbol="pango_coverage_to_bytes">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+          <parameter name="bytes" type="guchar**"/>
+          <parameter name="n_bytes" type="int*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="pango_coverage_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="coverage" type="PangoCoverage*"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct get-type="" name="PangoEngineLang" opaque="true" type-name="PangoEngineLang"/>
+    <struct get-type="" name="PangoEngineShape" opaque="true" type-name="PangoEngineShape"/>
+    <boxed get-type="" name="PangoFontDescription" opaque="true" type-name="PangoFontDescription">
+      <method name="better_match" symbol="pango_font_description_better_match">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+          <parameter name="old_match" type="const-PangoFontDescription*"/>
+          <parameter name="new_match" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="pango_font_description_copy">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="copy_static" symbol="pango_font_description_copy_static">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="equal" symbol="pango_font_description_equal">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="desc1" type="const-PangoFontDescription*"/>
+          <parameter name="desc2" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_font_description_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="from_string" symbol="pango_font_description_from_string">
+        <return-type type="PangoFontDescription*"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="get_family" symbol="pango_font_description_get_family">
+        <return-type type="const-char*"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_set_fields" symbol="pango_font_description_get_set_fields">
+        <return-type type="PangoFontMask"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="pango_font_description_get_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_size_is_absolute" symbol="pango_font_description_get_size_is_absolute">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_stretch" symbol="pango_font_description_get_stretch">
+        <return-type type="PangoStretch"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_style" symbol="pango_font_description_get_style">
+        <return-type type="PangoStyle"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_font_description_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_variant" symbol="pango_font_description_get_variant">
+        <return-type type="PangoVariant"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="get_weight" symbol="pango_font_description_get_weight">
+        <return-type type="PangoWeight"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="hash" symbol="pango_font_description_hash">
+        <return-type type="guint"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="merge" symbol="pango_font_description_merge">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="desc_to_merge" type="const-PangoFontDescription*"/>
+          <parameter name="replace_existing" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="merge_static" symbol="pango_font_description_merge_static">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="desc_to_merge" type="const-PangoFontDescription*"/>
+          <parameter name="replace_existing" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="pango_font_description_new">
+        <return-type type="PangoFontDescription*"/>
+      </method>
+      <method name="set_absolute_size" symbol="pango_font_description_set_absolute_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="size" type="double"/>
+        </parameters>
+      </method>
+      <method name="set_family" symbol="pango_font_description_set_family">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="family" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="set_family_static" symbol="pango_font_description_set_family_static">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="family" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="set_size" symbol="pango_font_description_set_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="size" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_stretch" symbol="pango_font_description_set_stretch">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="stretch" type="PangoStretch"/>
+        </parameters>
+      </method>
+      <method name="set_style" symbol="pango_font_description_set_style">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="style" type="PangoStyle"/>
+        </parameters>
+      </method>
+      <method name="set_variant" symbol="pango_font_description_set_variant">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="variant" type="PangoVariant"/>
+        </parameters>
+      </method>
+      <method name="set_weight" symbol="pango_font_description_set_weight">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="weight" type="PangoWeight"/>
+        </parameters>
+      </method>
+      <method name="to_filename" symbol="pango_font_description_to_filename">
+        <return-type type="char*"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="to_string" symbol="pango_font_description_to_string">
+        <return-type type="char*"/>
+        <parameters>
+          <parameter name="desc" type="const-PangoFontDescription*"/>
+        </parameters>
+      </method>
+      <method name="unset_fields" symbol="pango_font_description_unset_fields">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="desc" type="PangoFontDescription*"/>
+          <parameter name="to_unset" type="PangoFontMask"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="PangoFontMetrics" opaque="true" type-name="PangoFontMetrics">
+      <method name="get_approximate_char_width" symbol="pango_font_metrics_get_approximate_char_width">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_approximate_digit_width" symbol="pango_font_metrics_get_approximate_digit_width">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_ascent" symbol="pango_font_metrics_get_ascent">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_descent" symbol="pango_font_metrics_get_descent">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_strikethrough_position" symbol="pango_font_metrics_get_strikethrough_position">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_strikethrough_thickness" symbol="pango_font_metrics_get_strikethrough_thickness">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_font_metrics_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_underline_position" symbol="pango_font_metrics_get_underline_position">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="get_underline_thickness" symbol="pango_font_metrics_get_underline_thickness">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="pango_font_metrics_ref">
+        <return-type type="PangoFontMetrics*"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="pango_font_metrics_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="metrics" type="PangoFontMetrics*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoGlyphGeometry" type-name="PangoGlyphGeometry">
+      <field name="width" readable="1" type="PangoGlyphUnit" writable="1"/>
+      <field name="x_offset" readable="1" type="PangoGlyphUnit" writable="1"/>
+      <field name="y_offset" readable="1" type="PangoGlyphUnit" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoGlyphInfo" type-name="PangoGlyphInfo">
+      <field name="glyph" readable="1" type="PangoGlyph" writable="1"/>
+      <field name="geometry" readable="1" type="PangoGlyphGeometry" writable="1"/>
+      <field name="attr" readable="1" type="PangoGlyphVisAttr" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoGlyphItem" type-name="PangoGlyphItem">
+      <field name="item" readable="1" type="PangoItem*" writable="1"/>
+      <field name="glyphs" readable="1" type="PangoGlyphString*" writable="1"/>
+      <method name="apply_attrs" symbol="pango_glyph_item_apply_attrs">
+        <return-type type="GSList*"/>
+        <parameters>
+          <parameter name="glyph_item" type="PangoGlyphItem*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="list" type="PangoAttrList*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_glyph_item_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyph_item" type="PangoGlyphItem*"/>
+        </parameters>
+      </method>
+      <method name="letter_space" symbol="pango_glyph_item_letter_space">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyph_item" type="PangoGlyphItem*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="log_attrs" type="PangoLogAttr*"/>
+          <parameter name="letter_spacing" type="int"/>
+        </parameters>
+      </method>
+      <method name="split" symbol="pango_glyph_item_split">
+        <return-type type="PangoGlyphItem*"/>
+        <parameters>
+          <parameter name="orig" type="PangoGlyphItem*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="split_index" type="int"/>
+        </parameters>
+      </method>
+    </struct>
+    <boxed get-type="" name="PangoGlyphString" opaque="true" type-name="PangoGlyphString">
+      <field access="public" name="num_glyphs" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="glyphs" readable="1" type="PangoGlyphInfo*" writable="1" writeable="true"/>
+      <field access="public" name="log_clusters" readable="1" type="gint*" writable="1" writeable="true"/>
+      <field access="public" name="space" type="gint" writeable="true"/>
+      <method name="copy" symbol="pango_glyph_string_copy">
+        <return-type type="PangoGlyphString*"/>
+        <parameters>
+          <parameter name="string" type="PangoGlyphString*"/>
+        </parameters>
+      </method>
+      <method name="extents" symbol="pango_glyph_string_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="extents_range" symbol="pango_glyph_string_extents_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="start" type="int"/>
+          <parameter name="end" type="int"/>
+          <parameter name="font" type="PangoFont*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_glyph_string_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="string" type="PangoGlyphString*"/>
+        </parameters>
+      </method>
+      <method name="get_logical_widths" symbol="pango_glyph_string_get_logical_widths">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="length" type="int"/>
+          <parameter name="embedding_level" type="int"/>
+          <parameter name="logical_widths" type="int*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_glyph_string_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_width" symbol="pango_glyph_string_get_width">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+        </parameters>
+      </method>
+      <method name="index_to_x" symbol="pango_glyph_string_index_to_x">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="text" type="char*"/>
+          <parameter name="length" type="int"/>
+          <parameter name="analysis" type="PangoAnalysis*"/>
+          <parameter name="index_" type="int"/>
+          <parameter name="trailing" type="gboolean"/>
+          <parameter name="x_pos" type="int*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="pango_glyph_string_new">
+        <return-type type="PangoGlyphString*"/>
+      </method>
+      <method name="set_size" symbol="pango_glyph_string_set_size">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="string" type="PangoGlyphString*"/>
+          <parameter name="new_len" type="gint"/>
+        </parameters>
+      </method>
+      <method name="x_to_index" symbol="pango_glyph_string_x_to_index">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="glyphs" type="PangoGlyphString*"/>
+          <parameter name="text" type="char*"/>
+          <parameter name="length" type="int"/>
+          <parameter name="analysis" type="PangoAnalysis*"/>
+          <parameter name="x_pos" type="int"/>
+          <parameter name="index_" type="int*"/>
+          <parameter name="trailing" type="int*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoGlyphVisAttr" type-name="PangoGlyphVisAttr">
+      <field name="is_cluster_start" readable="1" type="guint" writable="1"/>
+    </struct>
+    <boxed get-type="" name="PangoItem" opaque="true" type-name="PangoItem">
+      <field access="public" name="offset" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="length" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="num_chars" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="analysis" readable="1" type="PangoAnalysis" writable="1" writeable="true"/>
+      <method name="copy" symbol="pango_item_copy">
+        <return-type type="PangoItem*"/>
+        <parameters>
+          <parameter name="item" type="PangoItem*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_item_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="item" type="PangoItem*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_item_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="pango_item_new">
+        <return-type type="PangoItem*"/>
+      </method>
+      <method name="split" symbol="pango_item_split">
+        <return-type type="PangoItem*"/>
+        <parameters>
+          <parameter name="orig" type="PangoItem*"/>
+          <parameter name="split_index" type="int"/>
+          <parameter name="split_offset" type="int"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="PangoLanguage" opaque="true" type-name="PangoLanguage">
+      <method name="from_string" symbol="pango_language_from_string">
+        <return-type type="PangoLanguage*"/>
+        <parameters>
+          <parameter name="language" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="get_sample_string" symbol="pango_language_get_sample_string">
+        <return-type type="const-char*"/>
+        <parameters>
+          <parameter name="language" type="PangoLanguage*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_language_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="includes_script" symbol="pango_language_includes_script">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="language" type="PangoLanguage*"/>
+          <parameter name="script" type="PangoScript"/>
+        </parameters>
+      </method>
+      <method name="matches" symbol="pango_language_matches">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="language" type="PangoLanguage*"/>
+          <parameter name="range_list" type="const-char*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="PangoLayoutIter" opaque="true" type-name="PangoLayoutIter">
+      <method name="at_last_line" symbol="pango_layout_iter_at_last_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_layout_iter_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="get_baseline" symbol="pango_layout_iter_get_baseline">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="get_char_extents" symbol="pango_layout_iter_get_char_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_cluster_extents" symbol="pango_layout_iter_get_cluster_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_index" symbol="pango_layout_iter_get_index">
+        <return-type type="int"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="get_layout_extents" symbol="pango_layout_iter_get_layout_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_line" symbol="pango_layout_iter_get_line">
+        <return-type type="PangoLayoutLine*"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="get_line_extents" symbol="pango_layout_iter_get_line_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_line_yrange" symbol="pango_layout_iter_get_line_yrange">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+          <parameter name="y0_" type="int*"/>
+          <parameter name="y1_" type="int*"/>
+        </parameters>
+      </method>
+      <method name="get_run" symbol="pango_layout_iter_get_run">
+        <return-type type="PangoLayoutRun*"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="get_run_extents" symbol="pango_layout_iter_get_run_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_layout_iter_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="next_char" symbol="pango_layout_iter_next_char">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="next_cluster" symbol="pango_layout_iter_next_cluster">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="next_line" symbol="pango_layout_iter_next_line">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+      <method name="next_run" symbol="pango_layout_iter_next_run">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="PangoLayoutIter*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <boxed get-type="" name="PangoLayoutLine" opaque="true" type-name="PangoLayoutLine">
+      <field access="public" name="layout" readable="1" type="PangoLayout*" writable="1" writeable="true"/>
+      <field access="public" name="start_index" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="length" readable="1" type="gint" writable="1" writeable="true"/>
+      <field access="public" name="runs" readable="1" type="GSList*" writable="1" writeable="true"/>
+      <field access="public" name="is_paragraph_start" readable="1" type="guint" writable="1" writeable="true"/>
+      <field access="public" name="resolved_dir" readable="1" type="guint" writable="1" writeable="true"/>
+      <method name="get_extents" symbol="pango_layout_line_get_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_pixel_extents" symbol="pango_layout_line_get_pixel_extents">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="layout_line" type="PangoLayoutLine*"/>
+          <parameter name="ink_rect" type="PangoRectangle*"/>
+          <parameter name="logical_rect" type="PangoRectangle*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_layout_line_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="get_x_ranges" symbol="pango_layout_line_get_x_ranges">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="start_index" type="int"/>
+          <parameter name="end_index" type="int"/>
+          <parameter name="ranges" type="int**"/>
+          <parameter name="n_ranges" type="int*"/>
+        </parameters>
+      </method>
+      <method name="index_to_x" symbol="pango_layout_line_index_to_x">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="index_" type="int"/>
+          <parameter name="trailing" type="gboolean"/>
+          <parameter name="x_pos" type="int*"/>
+        </parameters>
+      </method>
+      <method name="ref" symbol="pango_layout_line_ref">
+        <return-type type="PangoLayoutLine*"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+        </parameters>
+      </method>
+      <method name="unref" symbol="pango_layout_line_unref">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+        </parameters>
+      </method>
+      <method name="x_to_index" symbol="pango_layout_line_x_to_index">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="line" type="PangoLayoutLine*"/>
+          <parameter name="x_pos" type="int"/>
+          <parameter name="index_" type="int*"/>
+          <parameter name="trailing" type="int*"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoLayoutRun" type-name="PangoLayoutRun">
+      <field name="item" readable="1" type="PangoItem*" writable="1"/>
+      <field name="glyphs" readable="1" type="PangoGlyphString*" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoLogAttr" type-name="PangoLogAttr">
+      <field name="is_line_break" readable="1" type="guint" writable="1"/>
+      <field name="is_mandatory_break" readable="1" type="guint" writable="1"/>
+      <field name="is_char_break" readable="1" type="guint" writable="1"/>
+      <field name="is_white" readable="1" type="guint" writable="1"/>
+      <field name="is_cursor_position" readable="1" type="guint" writable="1"/>
+      <field name="is_word_start" readable="1" type="guint" writable="1"/>
+      <field name="is_word_end" readable="1" type="guint" writable="1"/>
+      <field name="is_sentence_boundary" readable="1" type="guint" writable="1"/>
+      <field name="is_sentence_start" readable="1" type="guint" writable="1"/>
+      <field name="is_sentence_end" readable="1" type="guint" writable="1"/>
+      <field name="backspace_deletes_character" readable="1" type="guint" writable="1"/>
+    </struct>
+    <boxed get-type="" name="PangoMatrix" type-name="PangoMatrix">
+      <field name="xx" readable="1" type="double" writable="1"/>
+      <field name="xy" readable="1" type="double" writable="1"/>
+      <field name="yx" readable="1" type="double" writable="1"/>
+      <field name="yy" readable="1" type="double" writable="1"/>
+      <field name="x0" readable="1" type="double" writable="1"/>
+      <field name="y0" readable="1" type="double" writable="1"/>
+      <method name="concat" symbol="pango_matrix_concat">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="matrix" type="PangoMatrix*"/>
+          <parameter name="new_matrix" type="const-PangoMatrix*"/>
+        </parameters>
+      </method>
+      <method name="copy" symbol="pango_matrix_copy">
+        <return-type type="PangoMatrix*"/>
+        <parameters>
+          <parameter name="matrix" type="const-PangoMatrix*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_matrix_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="matrix" type="PangoMatrix*"/>
+        </parameters>
+      </method>
+      <method name="get_font_scale_factor" symbol="pango_matrix_get_font_scale_factor">
+        <return-type type="double"/>
+        <parameters>
+          <parameter name="matrix" type="const-PangoMatrix*"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_matrix_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="rotate" symbol="pango_matrix_rotate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="matrix" type="PangoMatrix*"/>
+          <parameter name="degrees" type="double"/>
+        </parameters>
+      </method>
+      <method name="scale" symbol="pango_matrix_scale">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="matrix" type="PangoMatrix*"/>
+          <parameter name="scale_x" type="double"/>
+          <parameter name="scale_y" type="double"/>
+        </parameters>
+      </method>
+      <method name="translate" symbol="pango_matrix_translate">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="matrix" type="PangoMatrix*"/>
+          <parameter name="tx" type="double"/>
+          <parameter name="ty" type="double"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoRectangle" type-name="PangoRectangle">
+      <field name="x" readable="1" type="int" writable="1"/>
+      <field name="y" readable="1" type="int" writable="1"/>
+      <field name="width" readable="1" type="int" writable="1"/>
+      <field name="height" readable="1" type="int" writable="1"/>
+    </struct>
+    <struct get-type="" name="PangoScriptIter" opaque="true" type-name="PangoScriptIter">
+      <method name="free" symbol="pango_script_iter_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoScriptIter*"/>
+        </parameters>
+      </method>
+      <method name="get_range" symbol="pango_script_iter_get_range">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="iter" type="PangoScriptIter*"/>
+          <parameter direction="out" name="start" type="const-char**"/>
+          <parameter direction="out" name="end" type="const-char**"/>
+          <parameter name="script" type="PangoScript*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="pango_script_iter_new">
+        <return-type type="PangoScriptIter*"/>
+        <parameters>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="length" type="int"/>
+        </parameters>
+      </method>
+      <method name="next" symbol="pango_script_iter_next">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="iter" type="PangoScriptIter*"/>
+        </parameters>
+      </method>
+    </struct>
+    <boxed get-type="" name="PangoTabArray" opaque="true" type-name="PangoTabArray">
+      <method name="copy" symbol="pango_tab_array_copy">
+        <return-type type="PangoTabArray*"/>
+        <parameters>
+          <parameter name="src" type="PangoTabArray*"/>
+        </parameters>
+      </method>
+      <method name="free" symbol="pango_tab_array_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+        </parameters>
+      </method>
+      <method name="get_positions_in_pixels" symbol="pango_tab_array_get_positions_in_pixels">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+        </parameters>
+      </method>
+      <method name="get_size" symbol="pango_tab_array_get_size">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+        </parameters>
+      </method>
+      <method name="get_tab" symbol="pango_tab_array_get_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+          <parameter name="tab_index" type="gint"/>
+          <parameter name="alignment" type="PangoTabAlign*"/>
+          <parameter name="location" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="get_tabs" symbol="pango_tab_array_get_tabs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+          <parameter name="alignments" type="PangoTabAlign**"/>
+          <parameter name="locations" type="gint**"/>
+        </parameters>
+      </method>
+      <method name="get_type" symbol="pango_tab_array_get_type">
+        <return-type type="GType"/>
+      </method>
+      <method name="new" symbol="pango_tab_array_new">
+        <return-type type="PangoTabArray*"/>
+        <parameters>
+          <parameter name="initial_size" type="gint"/>
+          <parameter name="positions_in_pixels" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="new_with_positions" symbol="pango_tab_array_new_with_positions">
+        <return-type type="PangoTabArray*"/>
+        <parameters>
+          <parameter name="size" type="gint"/>
+          <parameter name="positions_in_pixels" type="gboolean"/>
+          <parameter name="first_alignment" type="PangoTabAlign"/>
+          <parameter name="first_position" type="gint"/>
+        </parameters>
+      </method>
+      <method name="resize" symbol="pango_tab_array_resize">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+          <parameter name="new_size" type="gint"/>
+        </parameters>
+      </method>
+      <method name="set_tab" symbol="pango_tab_array_set_tab">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="tab_array" type="PangoTabArray*"/>
+          <parameter name="tab_index" type="gint"/>
+          <parameter name="alignment" type="PangoTabAlign"/>
+          <parameter name="location" type="gint"/>
+        </parameters>
+      </method>
+    </boxed>
+    <struct get-type="" name="PangoWin32FontCache" opaque="true" type-name="PangoWin32FontCache">
+      <method name="free" symbol="pango_win32_font_cache_free">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cache" type="PangoWin32FontCache*"/>
+        </parameters>
+      </method>
+      <method name="load" symbol="pango_win32_font_cache_load">
+        <return-type type="HFONT"/>
+        <parameters>
+          <parameter name="cache" type="PangoWin32FontCache*"/>
+          <parameter name="logfont" type="const-LOGFONT*"/>
+        </parameters>
+      </method>
+      <method name="new" symbol="pango_win32_font_cache_new">
+        <return-type type="PangoWin32FontCache*"/>
+      </method>
+      <method name="unload" symbol="pango_win32_font_cache_unload">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="cache" type="PangoWin32FontCache*"/>
+          <parameter name="hfont" type="HFONT"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct name="PangoAttr">
+      <method name="background_new" symbol="pango_attr_background_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="red" type="guint16"/>
+          <parameter name="green" type="guint16"/>
+          <parameter name="blue" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="fallback_new" symbol="pango_attr_fallback_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="enable_fallback" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="family_new" symbol="pango_attr_family_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="family" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="foreground_new" symbol="pango_attr_foreground_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="red" type="guint16"/>
+          <parameter name="green" type="guint16"/>
+          <parameter name="blue" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="letter_spacing_new" symbol="pango_attr_letter_spacing_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="letter_spacing" type="int"/>
+        </parameters>
+      </method>
+      <method name="rise_new" symbol="pango_attr_rise_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="rise" type="int"/>
+        </parameters>
+      </method>
+      <method name="scale_new" symbol="pango_attr_scale_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="scale_factor" type="double"/>
+        </parameters>
+      </method>
+      <method name="stretch_new" symbol="pango_attr_stretch_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="stretch" type="PangoStretch"/>
+        </parameters>
+      </method>
+      <method name="strikethrough_color_new" symbol="pango_attr_strikethrough_color_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="red" type="guint16"/>
+          <parameter name="green" type="guint16"/>
+          <parameter name="blue" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="strikethrough_new" symbol="pango_attr_strikethrough_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="strikethrough" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="style_new" symbol="pango_attr_style_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="style" type="PangoStyle"/>
+        </parameters>
+      </method>
+      <method name="type_register" symbol="pango_attr_type_register">
+        <return-type type="PangoAttrType"/>
+        <parameters>
+          <parameter name="name" type="const-gchar*"/>
+        </parameters>
+      </method>
+      <method name="underline_color_new" symbol="pango_attr_underline_color_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="red" type="guint16"/>
+          <parameter name="green" type="guint16"/>
+          <parameter name="blue" type="guint16"/>
+        </parameters>
+      </method>
+      <method name="underline_new" symbol="pango_attr_underline_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="underline" type="PangoUnderline"/>
+        </parameters>
+      </method>
+      <method name="variant_new" symbol="pango_attr_variant_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="variant" type="PangoVariant"/>
+        </parameters>
+      </method>
+      <method name="weight_new" symbol="pango_attr_weight_new">
+        <return-type type="PangoAttribute*"/>
+        <parameters>
+          <parameter name="weight" type="PangoWeight"/>
+        </parameters>
+      </method>
+    </struct>
+    <struct cname="PangoGlobal" name="Global">
+      <method name="_find_base_dir" symbol="pango_find_base_dir">
+        <return-type type="PangoDirection"/>
+        <parameters>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+        </parameters>
+      </method>
+      <method name="_find_paragraph_boundary" symbol="pango_find_paragraph_boundary">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="const-gchar*"/>
+          <parameter name="length" type="gint"/>
+          <parameter name="paragraph_delimiter_index" type="gint*"/>
+          <parameter name="next_paragraph_start" type="gint*"/>
+        </parameters>
+      </method>
+      <method name="_get_log_attrs" symbol="pango_get_log_attrs">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="length" type="int"/>
+          <parameter name="level" type="int"/>
+          <parameter name="language" type="PangoLanguage*"/>
+          <parameter name="log_attrs" type="PangoLogAttr*"/>
+          <parameter name="attrs_len" type="int"/>
+        </parameters>
+      </method>
+      <method deprecated="1" name="_get_mirror_char" symbol="pango_get_mirror_char">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="ch" type="gunichar"/>
+          <parameter name="mirrored_ch" type="gunichar*"/>
+        </parameters>
+      </method>
+      <method name="_is_zero_width" symbol="pango_is_zero_width">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="ch" type="gunichar"/>
+        </parameters>
+      </method>
+      <method name="_itemize_with_base_dir" symbol="pango_itemize_with_base_dir">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="context" type="PangoContext*"/>
+          <parameter name="base_dir" type="PangoDirection"/>
+          <parameter name="text" type="const-char*"/>
+          <parameter name="start_index" type="int"/>
+          <parameter name="length" type="int"/>
+          <parameter name="attrs" type="PangoAttrList*"/>
+          <parameter name="cached_iter" type="PangoAttrIterator*"/>
+        </parameters>
+      </method>
+      <method name="_parse_markup" symbol="pango_parse_markup">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="markup_text" type="const-char*"/>
+          <parameter name="length" type="int"/>
+          <parameter name="accel_marker" type="gunichar"/>
+          <parameter name="attr_list" type="PangoAttrList**"/>
+          <parameter name="text" type="char**"/>
+          <parameter name="accel_char" type="gunichar*"/>
+          <parameter name="error" type="GError**"/>
+        </parameters>
+      </method>
+      <method name="_parse_stretch" symbol="pango_parse_stretch">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+          <parameter name="stretch" type="PangoStretch*"/>
+          <parameter name="warn" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_parse_style" symbol="pango_parse_style">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+          <parameter name="style" type="PangoStyle*"/>
+          <parameter name="warn" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_parse_variant" symbol="pango_parse_variant">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+          <parameter name="variant" type="PangoVariant*"/>
+          <parameter name="warn" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_parse_weight" symbol="pango_parse_weight">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+          <parameter name="weight" type="PangoWeight*"/>
+          <parameter name="warn" type="gboolean"/>
+        </parameters>
+      </method>
+      <method name="_quantize_line_geometry" symbol="pango_quantize_line_geometry">
+        <return-type type="void"/>
+        <parameters>
+          <parameter name="thickness" type="int*"/>
+          <parameter name="position" type="int*"/>
+        </parameters>
+      </method>
+      <method name="_read_line" symbol="pango_read_line">
+        <return-type type="gint"/>
+        <parameters>
+          <parameter name="stream" type="FILE*"/>
+          <parameter name="str" type="GString*"/>
+        </parameters>
+      </method>
+      <method name="_reorder_items" symbol="pango_reorder_items">
+        <return-type type="GList*"/>
+        <parameters>
+          <parameter name="logical_items" type="GList*"/>
+        </parameters>
+      </method>
+      <method name="_scan_int" symbol="pango_scan_int">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pos" type="const-char**"/>
+          <parameter name="out" type="int*"/>
+        </parameters>
+      </method>
+      <method name="_scan_string" symbol="pango_scan_string">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pos" type="const-char**"/>
+          <parameter name="out" type="GString*"/>
+        </parameters>
+      </method>
+      <method name="_scan_word" symbol="pango_scan_word">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pos" type="const-char**"/>
+          <parameter name="out" type="GString*"/>
+        </parameters>
+      </method>
+      <method name="_script_for_unichar" symbol="pango_script_for_unichar">
+        <return-type type="PangoScript"/>
+        <parameters>
+          <parameter name="ch" type="gunichar"/>
+        </parameters>
+      </method>
+      <method name="_script_get_sample_language" symbol="pango_script_get_sample_language">
+        <return-type type="PangoLanguage*"/>
+        <parameters>
+          <parameter name="script" type="PangoScript"/>
+        </parameters>
+      </method>
+      <method name="_skip_space" symbol="pango_skip_space">
+        <return-type type="gboolean"/>
+        <parameters>
+          <parameter name="pos" type="const-char**"/>
+        </parameters>
+      </method>
+      <method name="_split_file_list" symbol="pango_split_file_list">
+        <return-type type="char**"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="_trim_string" symbol="pango_trim_string">
+        <return-type type="char*"/>
+        <parameters>
+          <parameter name="str" type="const-char*"/>
+        </parameters>
+      </method>
+      <method name="_unichar_direction" symbol="pango_unichar_direction">
+        <return-type type="PangoDirection"/>
+        <parameters>
+          <parameter name="ch" type="gunichar"/>
+        </parameters>
+      </method>
+    </struct>
+  </namespace>
+</api>

diff --git a/vapigen/packages/pango/pango.metadata b/vapigen/packages/pango/pango.metadata
new file mode 100644 (file)
index 0000000..1d1800d
--- /dev/null
+++ b/vapigen/packages/pango/pango.metadata
@@ -0,0 +1,2 @@
+Pango cheader_filename="pango/pango.h"
+pango_attr_size_new_absolute hidden="1"

diff --git a/vapigen/packages/pango/pango.namespace b/vapigen/packages/pango/pango.namespace
new file mode 100644 (file)
index 0000000..1e0fa50
--- /dev/null
+++ b/vapigen/packages/pango/pango.namespace
@@ -0,0 +1 @@
+Pango

diff --git a/vapigen/vapigen/Makefile.am b/vapigen/vapigen/Makefile.am
new file mode 100644 (file)
index 0000000..9842b4b
--- /dev/null
+++ b/vapigen/vapigen/Makefile.am
@@ -0,0 +1,35 @@
+NULL =
+
+INCLUDES = \
+       $(GLIB_CFLAGS) \
+       $(VALA_CFLAGS) \
+       -I ../gobject-introspection \
+       $(NULL)
+
+bin_PROGRAMS = \
+       vapigen \
+       $(NULL)
+
+BUILT_SOURCES = vapigen.vala.stamp
+
+vapigen_SOURCES = \
+       vapigen.vala.stamp \
+       valagidlparser.c \
+       valagidlparser.h \
+       valagidlparser.vala \
+       valavapigen.c \
+       valavapigen.h \
+       valavapigen.vala \
+       $(NULL)
+
+vapigen.vala.stamp: $(filter %.vala,$(vapigen_SOURCES))
+       $(VALAC) --vapidir ../gobject-introspection --pkg gidl --pkg vala-1.0 $^
+       touch $@
+
+vapigen_LDADD = \
+       $(GLIB_LIBS) \
+       $(VALA_LIBS) \
+       ../gobject-introspection/libgidl.la \
+       $(NULL)
+
+EXTRA_DIST = vapigen.vala.stamp

diff --git a/vapigen/vapigen/valagidlparser.vala b/vapigen/vapigen/valagidlparser.vala
new file mode 100644 (file)
index 0000000..149a183
--- /dev/null
+++ b/vapigen/vapigen/valagidlparser.vala
@@ -0,0 +1,788 @@
+/* valagidlparser.vala
+ *
+ * Copyright (C) 2006  Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ *     Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+/**
+ * Code visitor parsing all GIDL files.
+ */
+public class Vala.GIdlParser : CodeVisitor {
+       private SourceReference current_source_reference;
+       
+       private DataType current_data_type;
+       private HashTable<string,string> codenode_attributes_map;
+       private HashTable<string,string> current_type_symbol_map;
+
+       /**
+        * Parse all source files in the specified code context and build a
+        * code tree.
+        *
+        * @param context a code context
+        */
+       public void parse (CodeContext! context) {
+               context.accept (this);
+       }
+
+       public override void visit_begin_source_file (SourceFile! source_file) {
+               if (source_file.filename.has_suffix (".gidl")) {
+                       parse_file (source_file);
+               }
+       }
+       
+       private void parse_file (SourceFile! source_file) {
+               Error error = null;
+               
+               string metadata_filename = "%s.metadata".printf (source_file.filename.ndup (source_file.filename.size () - ".gidl".size ()));
+               
+               codenode_attributes_map = new HashTable.full (str_hash, str_equal, g_free, g_free);
+               
+               if (File.test (metadata_filename, FileTest.EXISTS)) {
+                       string metadata;
+                       File.get_contents (metadata_filename, out metadata, null, out error);
+                       
+                       foreach (string line in metadata.split ("\n")) {
+                               var line_parts = line.split (" ", 2);
+                               if (line_parts[0] == null) {
+                                       continue;
+                               }
+                               
+                               codenode_attributes_map.insert (line_parts[0], line_parts[1]);
+                       }
+               }
+       
+               var modules = Idl.parse_file (source_file.filename, out error);
+               
+               if (error != null) {
+                       stdout.printf ("error parsing GIDL file: %s\n", error.message);
+               }
+               
+               current_source_reference = new SourceReference (source_file);
+               
+               foreach (IdlModule module in modules) {
+                       var ns = parse_module (module);
+                       source_file.add_namespace (ns);
+               }
+       }
+       
+       private ref Namespace parse_module (IdlModule! module) {
+               var ns = new Namespace (module.name, current_source_reference);
+               
+               var attributes = get_attributes (ns.name);
+               if (attributes != null) {
+                       foreach (string attr in attributes) {
+                               var nv = attr.split ("=", 2);
+                               if (nv[0] == "cheader_filename") {
+                                       ns.set_cheader_filename (eval (nv[1]));
+                               }
+                       }
+               }
+               
+               foreach (IdlNode node in module.entries) {
+                       if (node.type == IdlNodeTypeId.CALLBACK) {
+                               var cb = parse_callback ((IdlNodeFunction) node);
+                               if (cb == null) {
+                                       continue;
+                               }
+                               if (cb.name.has_prefix (module.name)) {
+                                       cb.name = cb.name.offset (module.name.len ());
+                               }
+                               ns.add_callback (cb);
+                       } else if (node.type == IdlNodeTypeId.STRUCT) {
+                               var st = parse_struct ((IdlNodeStruct) node);
+                               if (st == null) {
+                                       continue;
+                               }
+                               if (st.name.has_prefix (module.name)) {
+                                       st.name = st.name.offset (module.name.len ());
+                               }
+                               ns.add_struct (st);
+                       } else if (node.type == IdlNodeTypeId.BOXED) {
+                               var st = parse_boxed ((IdlNodeBoxed) node);
+                               if (st.name.has_prefix (module.name)) {
+                                       st.name = st.name.offset (module.name.len ());
+                               }
+                               ns.add_struct (st);
+                       } else if (node.type == IdlNodeTypeId.ENUM) {
+                               var en = parse_enum ((IdlNodeEnum) node);
+                               if (en.name.has_prefix (module.name)) {
+                                       en.name = en.name.offset (module.name.len ());
+                               }
+                               ns.add_enum (en);
+                       } else if (node.type == IdlNodeTypeId.OBJECT) {
+                               var cl = parse_object ((IdlNodeInterface) node);
+                               if (cl.name.has_prefix (module.name)) {
+                                       cl.name = cl.name.offset (module.name.len ());
+                               }
+                               ns.add_class (cl);
+                       } else if (node.type == IdlNodeTypeId.INTERFACE) {
+                               var iface = parse_interface ((IdlNodeInterface) node);
+                               if (iface.name.has_prefix (module.name)) {
+                                       iface.name = iface.name.offset (module.name.len ());
+                               }
+                               ns.add_interface (iface);
+                       } else if (node.type == IdlNodeTypeId.CONSTANT) {
+                               var c = parse_constant ((IdlNodeConstant) node);
+                               if (c.name.has_prefix (module.name.up ())) {
+                                       c.name = c.name.offset (module.name.len () + 1);
+                               }
+                               ns.add_constant (c);
+                       }
+               }
+               
+               return ns;
+       }
+       
+       private ref Callback parse_callback (IdlNodeFunction! f_node) {
+               var node = (IdlNode) f_node;
+
+               var attributes = get_attributes (node.name);
+               if (attributes != null) {
+                       foreach (string attr in attributes) {
+                               var nv = attr.split ("=", 2);
+                               if (nv[0] == "hidden") {
+                                       if (eval (nv[1]) == "1") {
+                                               return null;
+                                       }
+                               }
+                       }
+               }
+       
+               var cb = new Callback (node.name, parse_param (f_node.result), current_source_reference);
+               cb.access = MemberAccessibility.PUBLIC;
+               
+               foreach (IdlNodeParam param in f_node.parameters) {
+                       var param_node = (IdlNode) param;
+                       
+                       var p = new FormalParameter (param_node.name, parse_param (param));
+                       cb.add_parameter (p);
+               }
+               
+               return cb;
+       }
+       
+       private ref Struct parse_struct (IdlNodeStruct! st_node) {
+               var node = (IdlNode) st_node;
+               
+               if (st_node.deprecated) {
+                       return null;
+               }
+       
+               var st = new Struct (node.name, current_source_reference);
+               st.access = MemberAccessibility.PUBLIC;
+
+               st.set_is_reference_type (true);
+               
+               var st_attributes = get_attributes (node.name);
+               if (st_attributes != null) {
+                       foreach (string attr in st_attributes) {
+                               var nv = attr.split ("=", 2);
+                               if (nv[0] == "is_value_type" && eval (nv[1]) == "1") {
+                                       st.set_is_reference_type (false);
+                               }
+                       }
+               }
+               
+               current_data_type = st;
+               
+               foreach (IdlNode member in st_node.members) {
+                       if (member.type == IdlNodeTypeId.FUNCTION) {
+                               var m = parse_function ((IdlNodeFunction) member);
+                               if (m != null) {
+                                       st.add_method (m);
+                               }
+                       } else if (member.type == IdlNodeTypeId.FIELD) {
+                               var f = parse_field ((IdlNodeField) member);
+                               if (f != null) {
+                                       st.add_field (f);
+                               }
+                       }
+               }
+
+               current_data_type = null;
+               
+               return st;
+       }
+       
+       private ref Struct parse_boxed (IdlNodeBoxed! boxed_node) {
+               var node = (IdlNode) boxed_node;
+       
+               var st = new Struct (node.name, current_source_reference);
+               st.access = MemberAccessibility.PUBLIC;
+               
+               current_data_type = st;
+               
+               foreach (IdlNode member in boxed_node.members) {
+                       if (member.type == IdlNodeTypeId.FUNCTION) {
+                               var m = parse_function ((IdlNodeFunction) member);
+                               if (m != null) {
+                                       st.add_method (m);
+                               }
+                       }
+               }
+
+               current_data_type = null;
+               
+               return st;
+       }
+       
+       private ref Enum parse_enum (IdlNodeEnum! en_node) {
+               var node = (IdlNode) en_node;
+       
+               var en = new Enum (node.name, current_source_reference);
+               en.access = MemberAccessibility.PUBLIC;
+               
+               string common_prefix = null;
+               
+               foreach (IdlNode value in en_node.values) {
+                       if (common_prefix == null) {
+                               common_prefix = value.name;
+                               while (common_prefix.len () > 0 && !common_prefix.has_suffix ("_")) {
+                                       // FIXME: could easily be made faster
+                                       common_prefix = common_prefix.ndup (common_prefix.size () - 1);
+                               }
+                       } else {
+                               while (!value.name.has_prefix (common_prefix)) {
+                                       common_prefix = common_prefix.ndup (common_prefix.size () - 1);
+                               }
+                       }
+               }
+               
+               en.set_cprefix (common_prefix);
+               
+               foreach (IdlNode value2 in en_node.values) {
+                       var ev = new EnumValue (value2.name.offset (common_prefix.len ()));
+                       en.add_value (ev);
+               }
+               
+               return en;
+       }
+       
+       private ref Class parse_object (IdlNodeInterface! node) {
+
+               var cl = new Class (node.gtype_name, current_source_reference);
+               cl.access = MemberAccessibility.PUBLIC;
+               
+               if (node.parent != null) {
+                       var parent = new TypeReference ();
+                       parse_type_string (parent, node.parent);
+                       cl.add_base_type (parent);
+               }
+               
+               foreach (string iface_name in node.interfaces) {
+                       var iface = new TypeReference ();
+                       parse_type_string (iface, iface_name);
+                       cl.add_base_type (iface);
+               }
+               
+               current_data_type = cl;
+               
+               current_type_symbol_map = new HashTable.full (str_hash, str_equal, g_free, g_free);
+
+               foreach (IdlNode member in node.members) {
+                       if (member.type == IdlNodeTypeId.FUNCTION) {
+                               var m = parse_function ((IdlNodeFunction) member);
+                               if (m != null) {
+                                       cl.add_method (m);
+                               }
+                       } else if (member.type == IdlNodeTypeId.PROPERTY) {
+                               var prop = parse_property ((IdlNodeProperty) member);
+                               if (prop != null) {
+                                       cl.add_property (prop);
+                               }
+                       } else if (member.type == IdlNodeTypeId.SIGNAL) {
+                               var sig = parse_signal ((IdlNodeSignal) member);
+                               if (sig != null) {
+                                       cl.add_signal (sig);
+                               }
+                       }
+               }
+               
+               foreach (IdlNode member in node.members) {
+                       if (member.type == IdlNodeTypeId.FIELD) {
+                               if (current_type_symbol_map.lookup (member.name) == null) {
+                                       var f = parse_field ((IdlNodeField) member);
+                                       if (f != null) {
+                                               cl.add_field (f);
+                                       }
+                               }
+                       }
+               }
+               
+               foreach (Property prop in cl.get_properties ()) {
+                       var getter = "get_%s".printf (prop.name);
+                       
+                       if (prop.get_accessor != null && current_type_symbol_map.lookup (getter) == null) {
+                               prop.no_accessor_method = true;
+                       }
+                       
+                       var setter = "set_%s".printf (prop.name);
+                       
+                       if (prop.set_accessor != null && current_type_symbol_map.lookup (setter) == null) {
+                               prop.no_accessor_method = true;
+                       }
+               }
+               
+               current_data_type = null;
+               current_type_symbol_map = null;
+               
+               return cl;
+       }
+       
+       private ref Interface parse_interface (IdlNodeInterface! node) {
+               var iface = new Interface (node.gtype_name, current_source_reference);
+               iface.access = MemberAccessibility.PUBLIC;
+               
+               foreach (string prereq_name in node.prerequisites) {
+                       var prereq = new TypeReference ();
+                       parse_type_string (prereq, prereq_name);
+                       iface.add_base_type (prereq);
+               }
+
+               current_data_type = iface;
+
+               foreach (IdlNode member in node.members) {
+                       if (member.type == IdlNodeTypeId.FUNCTION) {
+                               var m = parse_function ((IdlNodeFunction) member);
+                               if (m != null) {
+                                       iface.add_method (m);
+                               }
+                       }
+               }
+
+               current_data_type = null;
+               
+               return iface;
+       }
+       
+       private ref TypeReference parse_type (IdlNodeType! type_node) {
+               var type = new TypeReference ();
+               if (type_node.tag == TypeTag.VOID) {
+                       if (type_node.is_pointer) {
+                               type.type_name = "pointer";
+                       } else {
+                               type.type_name = "void";
+                       }
+               } else if (type_node.tag == TypeTag.BOOLEAN) {
+                       type.type_name = "bool";
+               } else if (type_node.tag == TypeTag.INT8) {
+                       type.type_name = "char";
+               } else if (type_node.tag == TypeTag.UINT8) {
+                       type.type_name = "uchar";
+               } else if (type_node.tag == TypeTag.INT16) {
+                       type.type_name = "short";
+               } else if (type_node.tag == TypeTag.UINT16) {
+                       type.type_name = "ushort";
+               } else if (type_node.tag == TypeTag.INT32) {
+                       type.type_name = "int";
+               } else if (type_node.tag == TypeTag.UINT32) {
+                       type.type_name = "uint";
+               } else if (type_node.tag == TypeTag.INT64) {
+                       type.type_name = "int64";
+               } else if (type_node.tag == TypeTag.UINT64) {
+                       type.type_name = "uint64";
+               } else if (type_node.tag == TypeTag.INT) {
+                       type.type_name = "int";
+               } else if (type_node.tag == TypeTag.UINT) {
+                       type.type_name = "uint";
+               } else if (type_node.tag == TypeTag.LONG) {
+                       type.type_name = "long";
+               } else if (type_node.tag == TypeTag.ULONG) {
+                       type.type_name = "ulong";
+               } else if (type_node.tag == TypeTag.SSIZE) {
+                       type.type_name = "long";
+               } else if (type_node.tag == TypeTag.SIZE) {
+                       type.type_name = "ulong";
+               } else if (type_node.tag == TypeTag.FLOAT) {
+                       type.type_name = "float";
+               } else if (type_node.tag == TypeTag.DOUBLE) {
+                       type.type_name = "double";
+               } else if (type_node.tag == TypeTag.UTF8) {
+                       type.type_name = "string";
+               } else if (type_node.tag == TypeTag.FILENAME) {
+                       type.type_name = "string";
+               } else if (type_node.tag == TypeTag.ARRAY) {
+                       type = parse_type (type_node.parameter_type1);
+                       type.array_rank = 1;
+               } else if (type_node.tag == TypeTag.LIST) {
+                       type.namespace_name = "GLib";
+                       type.type_name = "List";
+               } else if (type_node.tag == TypeTag.SLIST) {
+                       type.namespace_name = "GLib";
+                       type.type_name = "SList";
+               } else if (type_node.tag == TypeTag.HASH) {
+                       type.namespace_name = "GLib";
+                       type.type_name = "HashTable";
+               } else if (type_node.tag == TypeTag.ERROR) {
+                       type.namespace_name = "GLib";
+                       type.type_name = "Error";
+               } else if (type_node.is_interface) {
+                       var n = type_node.@interface;
+                       
+                       if (n == "") {
+                               return null;
+                       }
+                       
+                       if (n.has_prefix ("const-")) {
+                               n = n.offset ("const-".len ());
+                       }
+
+                       if (type_node.is_pointer &&
+                           (n == "gchar" || n == "char")) {
+                               type.type_name = "string";
+                       } else if (n == "gunichar") {
+                               type.type_name = "unichar";
+                       } else if (n == "gchar") {
+                               type.type_name = "char";
+                       } else if (n == "guchar" || n == "guint8") {
+                               type.type_name = "uchar";
+                       } else if (n == "gushort") {
+                               type.type_name = "ushort";
+                       } else if (n == "gshort") {
+                               type.type_name = "short";
+                       } else if (n == "gconstpointer") {
+                               type.type_name = "pointer";
+                       } else if (n == "value_array") {
+                               type.namespace_name = "GLib";
+                               type.type_name = "ValueArray";
+                       } else if (n == "time_t") {
+                               type.type_name = "ulong";
+                       } else if (n == "FILE") {
+                               type.namespace_name = "GLib";
+                               type.type_name = "File";
+                       } else {
+                               parse_type_string (type, n);
+                       }
+               } else {
+                       stdout.printf ("%d\n", type_node.tag);
+               }
+               return type;
+       }
+       
+       private void parse_type_string (TypeReference! type, string! n) {
+               // Generated GIDL misses explicit namespace specifier,
+               // so try to guess namespace
+               if (n.has_prefix ("H") || n.has_suffix ("Class") || n == "va_list" || n == "LOGFONT") {
+                       // unsupported
+                       type.type_name = "pointer";
+               } else if (n.has_prefix ("cairo")) {
+                       type.namespace_name = "Cairo";
+                       if (n == "cairo_t") {
+                               type.type_name = "Context";
+                       } else if (n == "cairo_surface_t") {
+                               type.type_name = "Surface";
+                       } else {
+                               type.namespace_name = null;
+                               type.type_name = "pointer";
+                       }
+               } else if (n.has_prefix ("Atk")) {
+                       type.namespace_name = "Atk";
+                       type.type_name = n.offset ("Atk".len ());
+                       if (type.type_name == "AttributeSet") {
+                               type.namespace_name = "GLib";
+                               type.type_name = "SList";
+                       }
+               } else if (n.has_prefix ("Gtk")) {
+                       type.namespace_name = "Gtk";
+                       type.type_name = n.offset ("Gtk".len ());
+                       if (type.type_name == "Allocation" || type.type_name == "TextLayout") {
+                               type.namespace_name = null;
+                               type.type_name = "pointer";
+                       }
+               } else if (n.has_prefix ("Gdk")) {
+                       type.namespace_name = "Gdk";
+                       type.type_name = n.offset ("Gdk".len ());
+                       if (type.type_name == "NativeWindow" || type.type_name == "XEvent") {
+                               type.namespace_name = null;
+                               type.type_name = "pointer";
+                       }
+               } else if (n.has_prefix ("Pango")) {
+                       type.namespace_name = "Pango";
+                       type.type_name = n.offset ("Pango".len ());
+                       if (type.type_name == "Glyph") {
+                               type.namespace_name = null;
+                               type.type_name = "uint";
+                       } else if (type.type_name == "GlyphUnit") {
+                               type.namespace_name = null;
+                               type.type_name = "int";
+                       }
+               } else if (n.has_prefix ("G")) {
+                       type.namespace_name = "GLib";
+                       type.type_name = n.offset ("G".len ());
+                       if (type.type_name == "Strv") {
+                               type.namespace_name = null;
+                               type.type_name = "string";
+                               type.array_rank = 1;
+                       }
+               } else {
+                       var name_parts = n.split (".", 2);
+                       if (name_parts[1] == null) {
+                               type.type_name = name_parts[0];
+                       } else {
+                               type.namespace_name = name_parts[0];
+                               type.type_name = name_parts[1];
+                       }
+               }
+       }
+       
+       private ref TypeReference parse_param (IdlNodeParam! param) {
+               var type = parse_type (param.type);
+
+               // disable for now as null_ok not yet correctly set
+               // type.non_null = !param.null_ok;
+               
+               return type;
+       }
+       
+       private ref Method parse_function (IdlNodeFunction! f) {
+               var node = (IdlNode) f;
+               
+               if (f.deprecated) {
+                       return null;
+               }
+       
+               TypeReference return_type = null;
+               if (f.result != null) {
+                       return_type = parse_param (f.result);
+               }
+               
+               var m = new Method (node.name, return_type, current_source_reference);
+               m.access = MemberAccessibility.PUBLIC;
+               
+               if (current_type_symbol_map != null) {
+                       current_type_symbol_map.insert (node.name, "1");
+               }
+               
+               if (current_data_type != null) {
+                       var sig_attributes = get_attributes ("%s::%s".printf (current_data_type.name, node.name));
+                       if (sig_attributes != null) {
+                               foreach (string attr in sig_attributes) {
+                                       var nv = attr.split ("=", 2);
+                                       if (nv[0] == "has_emitter" && eval (nv[1]) == "1") {
+                                               return null;
+                                       }
+                               }
+                       }
+               }
+               
+               bool add_ellipsis = false;
+
+               var attributes = get_attributes (f.symbol);
+               if (attributes != null) {
+                       foreach (string attr in attributes) {
+                               var nv = attr.split ("=", 2);
+                               if (nv[0] == "hidden") {
+                                       if (eval (nv[1]) == "1") {
+                                               return null;
+                                       }
+                               } else if (nv[0] == "ellipsis") {
+                                       if (eval (nv[1]) == "1") {
+                                               add_ellipsis = true;
+                                       }
+                               }
+                       }
+               }
+               
+               if (f.is_constructor || m.name.has_prefix ("new")) {
+                       m.construction = true;
+                       if (m.name == "new") {
+                               m.name = null;
+                       } else if (m.name.has_prefix ("new_")) {
+                               m.name = m.name.offset ("new_".len ());
+                       }
+               }
+               
+               bool first = true;
+               foreach (IdlNodeParam param in f.parameters) {
+                       var param_node = (IdlNode) param;
+                       
+                       if (first) {
+                               first = false;
+                               if (current_data_type != null &&
+                                   param.type.is_interface &&
+                                   (param_node.name == "self" ||
+                                    param.type.@interface.has_suffix (current_data_type.name))) {
+                                       // instance method
+                                       continue;
+                               } else {
+                                       // static method
+                                       m.instance = false;
+                               }
+                       }
+                       
+                       var p = new FormalParameter (param_node.name, parse_param (param));
+                       m.add_parameter (p);
+               }
+               
+               if (add_ellipsis) {
+                       m.add_parameter (new FormalParameter.with_ellipsis ());
+               }
+               
+               return m;
+       }
+       
+       private ref string! fix_prop_name (string name) {
+               var str = new String ();
+               
+               string i = name;
+               
+               while (i.len () > 0) {
+                       unichar c = i.get_char ();
+                       if (c == '-') {
+                               str.append_c ('_');
+                       } else {
+                               str.append_unichar (c);
+                       }
+                       
+                       i = i.next_char ();
+               }
+               
+               return str.str;
+       }
+
+       private ref Property parse_property (IdlNodeProperty! prop_node) {
+               var node = (IdlNode) prop_node;
+               
+               if (prop_node.deprecated) {
+                       return null;
+               }
+               
+               if (!prop_node.readable && !prop_node.writable) {
+                       // buggy GIDL definition
+                       prop_node.readable = true;
+                       prop_node.writable = true;
+               }
+               
+               PropertyAccessor get_acc = null;
+               PropertyAccessor set_acc = null;
+               if (prop_node.readable) {
+                       get_acc = new PropertyAccessor (true, false, false, null, null);
+               }
+               if (prop_node.writable) {
+                       set_acc = new PropertyAccessor (false, false, false, null, null);
+                       if (prop_node.construct_only) {
+                               set_acc.construction = true;
+                       } else {
+                               set_acc.writable = true;
+                               set_acc.construction = prop_node.@construct;
+                       }
+               }
+               
+               var prop = new Property (fix_prop_name (node.name), parse_type (prop_node.type), get_acc, set_acc, current_source_reference);
+               prop.access = MemberAccessibility.PUBLIC;
+               prop.interface_only = true;
+               
+               if (current_type_symbol_map != null) {
+                       current_type_symbol_map.insert (prop.name, "1");
+               }
+               
+               return prop;
+       }
+
+       private ref Constant parse_constant (IdlNodeConstant! const_node) {
+               var node = (IdlNode) const_node;
+               
+               var type = parse_type (const_node.type);
+               if (type == null) {
+                       return null;
+               }
+               
+               var c = new Constant (node.name, type, null, current_source_reference);
+               
+               return c;
+       }
+
+       private ref Field parse_field (IdlNodeField! field_node) {
+               var node = (IdlNode) field_node;
+               
+               var type = parse_type (field_node.type);
+               if (type == null) {
+                       return null;
+               }
+               
+               if (!field_node.readable) {
+                       return null;
+               }
+               
+               if (current_type_symbol_map != null) {
+                       current_type_symbol_map.insert (node.name, "1");
+               }
+               
+               var field = new Field (node.name, type, null, current_source_reference);
+               field.access = MemberAccessibility.PUBLIC;
+               
+               return field;
+       }
+       
+       private ref string[] get_attributes (string! codenode) {
+               string attributes = codenode_attributes_map.lookup (codenode);
+               if (attributes == null) {
+                       return null;
+               }
+               
+               return attributes.split (" ");
+       }
+       
+       private ref string eval (string! s) {
+               return s.offset (1).ndup (s.size () - 2);
+       }
+
+       private ref Signal parse_signal (IdlNodeSignal! sig_node) {
+               var node = (IdlNode) sig_node;
+               
+               if (sig_node.deprecated || sig_node.result == null) {
+                       return null;
+               }
+               
+               var sig = new Signal (fix_prop_name (node.name), parse_param (sig_node.result), current_source_reference);
+               sig.access = MemberAccessibility.PUBLIC;
+               
+               var attributes = get_attributes ("%s::%s".printf (current_data_type.name, sig.name));
+               if (attributes != null) {
+                       foreach (string attr in attributes) {
+                               var nv = attr.split ("=", 2);
+                               if (nv[0] == "name") {
+                                       sig.set_cname (sig.name);
+                                       sig.name = eval (nv[1]);
+                               } else if (nv[0] == "has_emitter" && eval (nv[1]) == "1") {
+                                       sig.has_emitter = true;
+                               }
+                       }
+               }
+               
+               bool first = true;
+               
+               foreach (IdlNodeParam param in sig_node.parameters) {
+                       if (first) {
+                               // ignore implicit first signal parameter (sender)
+                               first = false;
+                               continue;
+                       }
+               
+                       var param_node = (IdlNode) param;
+                       
+                       var p = new FormalParameter (param_node.name, parse_param (param));
+                       sig.add_parameter (p);
+               }
+               
+               return sig;
+       }
+}

diff --git a/vapigen/vapigen/valavapigen.vala b/vapigen/vapigen/valavapigen.vala
new file mode 100644 (file)
index 0000000..8d29805
--- /dev/null
+++ b/vapigen/vapigen/valavapigen.vala
@@ -0,0 +1,191 @@
+/* valavapigen.vala
+ *
+ * Copyright (C) 2006  Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ *     Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+class Vala.VAPIGen {
+       static string directory;
+       static bool version;
+       static string[] sources;
+       static string[] vapi_directories;
+       static string library;
+       static string[] packages;
+       static bool disable_memory_management;
+       CodeContext context;
+
+       const OptionEntry[] options = {
+               { "vapidir", 0, 0, OptionArg.FILENAME_ARRAY, out vapi_directories, "Look for package bindings in DIRECTORY", "DIRECTORY..." },
+               { "pkg", 0, 0, OptionArg.STRING_ARRAY, out packages, "Include binding for PACKAGE", "PACKAGE..." },
+               { "library", 0, 0, OptionArg.STRING, out library, "Library name", "NAME" },
+               { "directory", 'd', 0, OptionArg.FILENAME, out directory, "Output directory", "DIRECTORY" },
+               { "version", 0, 0, OptionArg.NONE, ref version, "Display version number", null },
+               { "", 0, 0, OptionArg.FILENAME_ARRAY, out sources, null, "FILE..." },
+               { null }
+       };
+       
+       private int quit () {
+               if (Report.get_errors () == 0) {
+                       stdout.printf ("Generation succeeded - %d warning(s)\n", Report.get_warnings ());
+                       return 0;
+               } else {
+                       stdout.printf ("Generation failed: %d error(s), %d warning(s)\n", Report.get_errors (), Report.get_warnings ());
+                       return 1;
+               }
+       }
+       
+       private ref string get_package_path (string! pkg) {
+               var basename = "%s.vala".printf (pkg);
+       
+               if (vapi_directories != null) {
+                       foreach (string vapidir in vapi_directories) {
+                               var filename = Path.build_filename (vapidir, basename, null);
+                               if (File.test (filename, FileTest.EXISTS)) {
+                                       return filename;
+                               }
+                       }
+               }
+               
+               var filename = Path.build_filename ("/usr/local/share/vala/vapi", basename, null);
+               if (File.test (filename, FileTest.EXISTS)) {
+                       return filename;
+               }
+               
+               filename = Path.build_filename ("/usr/share/vala/vapi", basename, null);
+               if (File.test (filename, FileTest.EXISTS)) {
+                       return filename;
+               }
+               
+               return null;
+       }
+       
+       private bool add_package (string! pkg) {
+               var package_path = get_package_path (pkg);
+               
+               if (package_path == null) {
+                       return false;
+               }
+               
+               context.add_source_file (new SourceFile (context, package_path, true));
+               
+               return true;
+       }
+       
+       private int run () {
+               context = new CodeContext ();
+               
+               /* default package */
+               if (!add_package ("glib-2.0")) {
+                       Report.error (null, "glib-2.0 not found in specified Vala API directories");
+               }
+               
+               if (packages != null) {
+                       foreach (string package in packages) {
+                               if (!add_package (package)) {
+                                       Report.error (null, "%s not found in specified Vala API directories".printf (package));
+                               }
+                       }
+                       packages = null;
+               }
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               foreach (string source in sources) {
+                       if (File.test (source, FileTest.EXISTS)) {
+                               context.add_source_file (new SourceFile (context, source));
+                       } else {
+                               Report.error (null, "%s not found".printf (source));
+                       }
+               }
+               sources = null;
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               var parser = new Parser ();
+               parser.parse (context);
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               var gidlparser = new GIdlParser ();
+               gidlparser.parse (context);
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               var builder = new SymbolBuilder ();
+               builder.build (context);
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               var attributeprocessor = new AttributeProcessor ();
+               attributeprocessor.process (context);
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               var resolver = new SymbolResolver ();
+               resolver.resolve (context);
+               
+               if (Report.get_errors () > 0) {
+                       return quit ();
+               }
+               
+               if (library != null) {
+                       var interface_writer = new InterfaceWriter ();
+                       interface_writer.write_file (context, "%s.vala".printf (library));
+                       
+                       library = null;
+               }
+               
+               return quit ();
+       }
+       
+       static int main (int argc, string[] argv) {
+               Error err = null;
+       
+               var opt_context = new OptionContext ("- Vala API Generator");
+               opt_context.set_help_enabled (true);
+               opt_context.add_main_entries (options, null);
+               opt_context.parse (ref argc, out argv, out err);
+               
+               if (err != null) {
+                       return 1;
+               }
+               
+               if (sources == null) {
+                       stderr.printf ("No source file specified.\n");
+                       return 1;
+               }
+               
+               var vapigen = new VAPIGen ();
+               return vapigen.run ();
+       }
+}